diff --git a/src/Makefile.am b/src/Makefile.am
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -103,6 +103,7 @@
 BITCOIN_CORE_H = \
   addrdb.h \
   addrman.h \
+  attributes.h \
   avalanche.h \
   banman.h \
   base58.h \
diff --git a/src/attributes.h b/src/attributes.h
new file mode 100644
--- /dev/null
+++ b/src/attributes.h
@@ -0,0 +1,22 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2018 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_ATTRIBUTES_H
+#define BITCOIN_ATTRIBUTES_H
+
+#if defined(__has_cpp_attribute)
+#if __has_cpp_attribute(nodiscard)
+#define NODISCARD [[nodiscard]]
+#endif
+#endif
+#ifndef NODISCARD
+#if defined(_MSC_VER) && _MSC_VER >= 1700
+#define NODISCARD _Check_return_
+#else
+#define NODISCARD __attribute__((warn_unused_result))
+#endif
+#endif
+
+#endif // BITCOIN_ATTRIBUTES_H
diff --git a/src/base58.h b/src/base58.h
--- a/src/base58.h
+++ b/src/base58.h
@@ -16,6 +16,8 @@
 #ifndef BITCOIN_BASE58_H
 #define BITCOIN_BASE58_H
 
+#include <attributes.h>
+
 #include <string>
 #include <vector>
 
@@ -35,13 +37,14 @@
  * return true if decoding is successful.
  * psz cannot be nullptr.
  */
-bool DecodeBase58(const char *psz, std::vector<uint8_t> &vchRet);
+NODISCARD bool DecodeBase58(const char *psz, std::vector<uint8_t> &vchRet);
 
 /**
  * Decode a base58-encoded string (str) into a byte vector (vchRet).
  * return true if decoding is successful.
  */
-bool DecodeBase58(const std::string &str, std::vector<uint8_t> &vchRet);
+NODISCARD bool DecodeBase58(const std::string &str,
+                            std::vector<uint8_t> &vchRet);
 
 /**
  * Encode a byte vector into a base58-encoded string, including checksum
@@ -52,12 +55,13 @@
  * Decode a base58-encoded string (psz) that includes a checksum into a byte
  * vector (vchRet), return true if decoding is successful
  */
-bool DecodeBase58Check(const char *psz, std::vector<uint8_t> &vchRet);
+NODISCARD bool DecodeBase58Check(const char *psz, std::vector<uint8_t> &vchRet);
 
 /**
  * Decode a base58-encoded string (str) that includes a checksum into a byte
  * vector (vchRet), return true if decoding is successful
  */
-bool DecodeBase58Check(const std::string &str, std::vector<uint8_t> &vchRet);
+NODISCARD bool DecodeBase58Check(const std::string &str,
+                                 std::vector<uint8_t> &vchRet);
 
 #endif // BITCOIN_BASE58_H
diff --git a/src/bench/base58.cpp b/src/bench/base58.cpp
--- a/src/bench/base58.cpp
+++ b/src/bench/base58.cpp
@@ -35,7 +35,7 @@
     const char *addr = "17VZNX1SN5NtKa8UQFxwQbFeFc3iqRYhem";
     std::vector<uint8_t> vch;
     while (state.KeepRunning()) {
-        DecodeBase58(addr, vch);
+        (void)DecodeBase58(addr, vch);
     }
 }
 
diff --git a/src/core_io.h b/src/core_io.h
--- a/src/core_io.h
+++ b/src/core_io.h
@@ -5,6 +5,7 @@
 #ifndef BITCOIN_CORE_IO_H
 #define BITCOIN_CORE_IO_H
 
+#include <attributes.h>
 #include <script/sighashtype.h>
 
 #include <string>
@@ -24,13 +25,14 @@
 CScript ParseScript(const std::string &s);
 std::string ScriptToAsmStr(const CScript &script,
                            const bool fAttemptSighashDecode = false);
-bool DecodeHexTx(CMutableTransaction &tx, const std::string &strHexTx);
-bool DecodeHexBlk(CBlock &, const std::string &strHexBlk);
+NODISCARD bool DecodeHexTx(CMutableTransaction &tx,
+                           const std::string &strHexTx);
+NODISCARD bool DecodeHexBlk(CBlock &, const std::string &strHexBlk);
 bool DecodeHexBlockHeader(CBlockHeader &, const std::string &hex_header);
 uint256 ParseHashStr(const std::string &, const std::string &strName);
 std::vector<uint8_t> ParseHexUV(const UniValue &v, const std::string &strName);
-bool DecodePSBT(PartiallySignedTransaction &psbt, const std::string &base64_tx,
-                std::string &error);
+NODISCARD bool DecodePSBT(PartiallySignedTransaction &psbt,
+                          const std::string &base64_tx, std::string &error);
 SigHashType ParseSighashString(const UniValue &sighash);
 
 // core_write.cpp
diff --git a/src/miner.cpp b/src/miner.cpp
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -91,9 +91,9 @@
             gArgs.GetArg("-blockmaxsize", DEFAULT_MAX_GENERATED_BLOCK_SIZE);
     }
 
-    if (gArgs.IsArgSet("-blockmintxfee")) {
-        Amount n = Amount::zero();
-        ParseMoney(gArgs.GetArg("-blockmintxfee", ""), n);
+    Amount n = Amount::zero();
+    if (gArgs.IsArgSet("-blockmintxfee") &&
+        ParseMoney(gArgs.GetArg("-blockmintxfee", ""), n)) {
         options.blockMinFeeRate = CFeeRate(n);
     }
 
diff --git a/src/outputtype.h b/src/outputtype.h
--- a/src/outputtype.h
+++ b/src/outputtype.h
@@ -6,6 +6,7 @@
 #ifndef BITCOIN_OUTPUTTYPE_H
 #define BITCOIN_OUTPUTTYPE_H
 
+#include <attributes.h>
 #include <keystore.h>
 #include <script/standard.h>
 
@@ -22,7 +23,7 @@
     CHANGE_AUTO,
 };
 
-bool ParseOutputType(const std::string &str, OutputType &output_type);
+NODISCARD bool ParseOutputType(const std::string &str, OutputType &output_type);
 const std::string &FormatOutputType(OutputType type);
 
 /**
diff --git a/src/rest.cpp b/src/rest.cpp
--- a/src/rest.cpp
+++ b/src/rest.cpp
@@ -3,6 +3,7 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <attributes.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <config.h>
diff --git a/src/script/descriptor.cpp b/src/script/descriptor.cpp
--- a/src/script/descriptor.cpp
+++ b/src/script/descriptor.cpp
@@ -510,7 +510,8 @@
  * Parse a key path, being passed a split list of elements (the first element is
  * ignored).
  */
-bool ParseKeyPath(const std::vector<Span<const char>> &split, KeyPath &out) {
+NODISCARD bool ParseKeyPath(const std::vector<Span<const char>> &split,
+                            KeyPath &out) {
     for (size_t i = 1; i < split.size(); ++i) {
         Span<const char> elem = split[i];
         bool hardened = false;
diff --git a/src/test/getarg_tests.cpp b/src/test/getarg_tests.cpp
--- a/src/test/getarg_tests.cpp
+++ b/src/test/getarg_tests.cpp
@@ -30,7 +30,7 @@
     }
 
     std::string error;
-    am.ParseParameters(vecChar.size(), vecChar.data(), error);
+    BOOST_CHECK(am.ParseParameters(vecChar.size(), vecChar.data(), error));
 }
 
 static void SetupArgs(ArgsManager &am, const std::vector<std::string> &args) {
diff --git a/src/test/util_tests.cpp b/src/test/util_tests.cpp
--- a/src/test/util_tests.cpp
+++ b/src/test/util_tests.cpp
@@ -194,15 +194,15 @@
 
     std::string error;
     testArgs.SetupArgs(4, avail_args);
-    testArgs.ParseParameters(0, (char **)argv_test, error);
+    BOOST_CHECK(testArgs.ParseParameters(0, (char **)argv_test, error));
     BOOST_CHECK(testArgs.GetOverrideArgs().empty() &&
                 testArgs.GetConfigArgs().empty());
 
-    testArgs.ParseParameters(1, (char **)argv_test, error);
+    BOOST_CHECK(testArgs.ParseParameters(1, (char **)argv_test, error));
     BOOST_CHECK(testArgs.GetOverrideArgs().empty() &&
                 testArgs.GetConfigArgs().empty());
 
-    testArgs.ParseParameters(7, (char **)argv_test, error);
+    BOOST_CHECK(testArgs.ParseParameters(7, (char **)argv_test, error));
     // expectation: -ignored is ignored (program name argument),
     // -a, -b and -ccc end up in map, -d ignored because it is after
     // a non-option argument (non-GNU option parsing)
@@ -232,7 +232,7 @@
                                "-d=1",    "-e=false", "-f=true"};
     std::string error;
     testArgs.SetupArgs(6, avail_args);
-    testArgs.ParseParameters(7, (char **)argv_test, error);
+    BOOST_CHECK(testArgs.ParseParameters(7, (char **)argv_test, error));
 
     // Each letter should be set.
     for (const char opt : "abcdef") {
@@ -268,7 +268,7 @@
     const char *argv_test[] = {"ignored", "-nofoo", "-foo", "-nobar=0"};
     testArgs.SetupArgs(2, avail_args);
     std::string error;
-    testArgs.ParseParameters(4, (char **)argv_test, error);
+    BOOST_CHECK(testArgs.ParseParameters(4, (char **)argv_test, error));
 
     // This was passed twice, second one overrides the negative setting.
     BOOST_CHECK(!testArgs.IsArgNegated("-foo"));
@@ -280,7 +280,7 @@
 
     // Config test
     const char *conf_test = "nofoo=1\nfoo=1\nnobar=0\n";
-    testArgs.ParseParameters(1, (char **)argv_test, error);
+    BOOST_CHECK(testArgs.ParseParameters(1, (char **)argv_test, error));
     testArgs.ReadConfigString(conf_test);
 
     // This was passed twice, second one overrides the negative setting,
@@ -295,7 +295,7 @@
     // Combined test
     const char *combo_test_args[] = {"ignored", "-nofoo", "-bar"};
     const char *combo_test_conf = "foo=1\nnobar=1\n";
-    testArgs.ParseParameters(3, (char **)combo_test_args, error);
+    BOOST_CHECK(testArgs.ParseParameters(3, (char **)combo_test_args, error));
     testArgs.ReadConfigString(combo_test_conf);
 
     // Command line overrides, but doesn't erase old setting
@@ -641,38 +641,38 @@
     const char *testnetconf = "testnet=1\nregtest=0\n[test]\nregtest=1";
     std::string error;
 
-    test_args.ParseParameters(0, (char **)argv_testnet, error);
+    BOOST_CHECK(test_args.ParseParameters(0, (char **)argv_testnet, error));
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "main");
 
-    test_args.ParseParameters(2, (char **)argv_testnet, error);
+    BOOST_CHECK(test_args.ParseParameters(2, (char **)argv_testnet, error));
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
-    test_args.ParseParameters(2, (char **)argv_regtest, error);
+    BOOST_CHECK(test_args.ParseParameters(2, (char **)argv_regtest, error));
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "regtest");
 
-    test_args.ParseParameters(3, (char **)argv_test_no_reg, error);
+    BOOST_CHECK(test_args.ParseParameters(3, (char **)argv_test_no_reg, error));
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
-    test_args.ParseParameters(3, (char **)argv_both, error);
+    BOOST_CHECK(test_args.ParseParameters(3, (char **)argv_both, error));
     BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);
 
-    test_args.ParseParameters(0, (char **)argv_testnet, error);
+    BOOST_CHECK(test_args.ParseParameters(0, (char **)argv_testnet, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
-    test_args.ParseParameters(2, (char **)argv_testnet, error);
+    BOOST_CHECK(test_args.ParseParameters(2, (char **)argv_testnet, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
-    test_args.ParseParameters(2, (char **)argv_regtest, error);
+    BOOST_CHECK(test_args.ParseParameters(2, (char **)argv_regtest, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);
 
-    test_args.ParseParameters(3, (char **)argv_test_no_reg, error);
+    BOOST_CHECK(test_args.ParseParameters(3, (char **)argv_test_no_reg, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
-    test_args.ParseParameters(3, (char **)argv_both, error);
+    BOOST_CHECK(test_args.ParseParameters(3, (char **)argv_both, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);
 
@@ -680,23 +680,23 @@
     // [test] regtest=1 potentially relevant) doesn't break things
     test_args.SelectConfigNetwork("test");
 
-    test_args.ParseParameters(0, (char **)argv_testnet, error);
+    BOOST_CHECK(test_args.ParseParameters(0, (char **)argv_testnet, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
-    test_args.ParseParameters(2, (char **)argv_testnet, error);
+    BOOST_CHECK(test_args.ParseParameters(2, (char **)argv_testnet, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
-    test_args.ParseParameters(2, (char **)argv_regtest, error);
+    BOOST_CHECK(test_args.ParseParameters(2, (char **)argv_regtest, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);
 
-    test_args.ParseParameters(2, (char **)argv_test_no_reg, error);
+    BOOST_CHECK(test_args.ParseParameters(2, (char **)argv_test_no_reg, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
-    test_args.ParseParameters(3, (char **)argv_both, error);
+    BOOST_CHECK(test_args.ParseParameters(3, (char **)argv_both, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);
 }
diff --git a/src/util/moneystr.h b/src/util/moneystr.h
--- a/src/util/moneystr.h
+++ b/src/util/moneystr.h
@@ -10,6 +10,7 @@
 #define BITCOIN_UTIL_MONEYSTR_H
 
 #include <amount.h>
+#include <attributes.h>
 
 #include <cstdint>
 #include <string>
@@ -19,7 +20,7 @@
  * JSON but use AmountFromValue and ValueFromAmount for that.
  */
 std::string FormatMoney(const Amount n);
-bool ParseMoney(const std::string &str, Amount &nRet);
-bool ParseMoney(const char *pszIn, Amount &nRet);
+NODISCARD bool ParseMoney(const std::string &str, Amount &nRet);
+NODISCARD bool ParseMoney(const char *pszIn, Amount &nRet);
 
 #endif // BITCOIN_UTIL_MONEYSTR_H
diff --git a/src/util/strencodings.h b/src/util/strencodings.h
--- a/src/util/strencodings.h
+++ b/src/util/strencodings.h
@@ -9,6 +9,8 @@
 #ifndef BITCOIN_UTIL_STRENCODINGS_H
 #define BITCOIN_UTIL_STRENCODINGS_H
 
+#include <attributes.h>
+
 #include <cstdint>
 #include <string>
 #include <vector>
@@ -89,14 +91,14 @@
  * @returns true if the entire string could be parsed as valid integer, false if
  * not the entire string could be parsed or when overflow or underflow occurred.
  */
-bool ParseInt32(const std::string &str, int32_t *out);
+NODISCARD bool ParseInt32(const std::string &str, int32_t *out);
 
 /**
  * Convert string to signed 64-bit integer with strict parse error feedback.
  * @returns true if the entire string could be parsed as valid integer, false if
  * not the entire string could be parsed or when overflow or underflow occurred.
  */
-bool ParseInt64(const std::string &str, int64_t *out);
+NODISCARD bool ParseInt64(const std::string &str, int64_t *out);
 
 /**
  * Convert decimal string to unsigned 32-bit integer with strict parse error
@@ -104,7 +106,7 @@
  * @returns true if the entire string could be parsed as valid integer, false if
  * not the entire string could be parsed or when overflow or underflow occurred.
  */
-bool ParseUInt32(const std::string &str, uint32_t *out);
+NODISCARD bool ParseUInt32(const std::string &str, uint32_t *out);
 
 /**
  * Convert decimal string to unsigned 64-bit integer with strict parse error
@@ -112,14 +114,14 @@
  * @returns true if the entire string could be parsed as valid integer, false if
  * not the entire string could be parsed or when overflow or underflow occurred.
  */
-bool ParseUInt64(const std::string &str, uint64_t *out);
+NODISCARD bool ParseUInt64(const std::string &str, uint64_t *out);
 
 /**
  * Convert string to double with strict parse error feedback.
  * @returns true if the entire string could be parsed as valid double, false if
  * not the entire string could be parsed or when overflow or underflow occurred.
  */
-bool ParseDouble(const std::string &str, double *out);
+NODISCARD bool ParseDouble(const std::string &str, double *out);
 
 template <typename T>
 std::string HexStr(const T itbegin, const T itend, bool fSpaces = false) {
@@ -168,7 +170,8 @@
  * @note The result must be in the range (-10^18,10^18), otherwise an overflow
  * error will trigger.
  */
-bool ParseFixedPoint(const std::string &val, int decimals, int64_t *amount_out);
+NODISCARD bool ParseFixedPoint(const std::string &val, int decimals,
+                               int64_t *amount_out);
 
 /**
  * Convert from one power-of-2 number base to another.
@@ -206,8 +209,8 @@
 }
 
 /** Parse an HD keypaths like "m/7/0'/2000". */
-bool ParseHDKeypath(const std::string &keypath_str,
-                    std::vector<uint32_t> &keypath);
+NODISCARD bool ParseHDKeypath(const std::string &keypath_str,
+                              std::vector<uint32_t> &keypath);
 
 /**
  * Converts the given character to its lowercase equivalent.
diff --git a/src/util/strencodings.cpp b/src/util/strencodings.cpp
--- a/src/util/strencodings.cpp
+++ b/src/util/strencodings.cpp
@@ -462,7 +462,7 @@
     return std::string((const char *)vchRet.data(), vchRet.size());
 }
 
-static bool ParsePrechecks(const std::string &str) {
+NODISCARD static bool ParsePrechecks(const std::string &str) {
     // No empty string allowed
     if (str.empty()) {
         return false;
diff --git a/src/util/system.h b/src/util/system.h
--- a/src/util/system.h
+++ b/src/util/system.h
@@ -14,6 +14,7 @@
 #include <config/bitcoin-config.h>
 #endif
 
+#include <attributes.h>
 #include <compat.h>
 #include <compat/assumptions.h>
 #include <fs.h>
@@ -162,8 +163,8 @@
      */
     void SelectConfigNetwork(const std::string &network);
 
-    bool ParseParameters(int argc, const char *const argv[],
-                         std::string &error);
+    NODISCARD bool ParseParameters(int argc, const char *const argv[],
+                                   std::string &error);
     bool ReadConfigFiles(std::string &error, bool ignore_invalid_keys = false);
 
     /**