diff --git a/ci/dash/lint-tidy.sh b/ci/dash/lint-tidy.sh
index b186650db63ea..c4d9ab5ed431b 100755
--- a/ci/dash/lint-tidy.sh
+++ b/ci/dash/lint-tidy.sh
@@ -44,6 +44,7 @@ iwyu_tool.py \
   "src/util/moneystr.cpp" \
   "src/util/serfloat.cpp" \
   "src/util/spanparsing.cpp" \
+  "src/util/string.cpp" \
   "src/util/strencodings.cpp" \
   "src/util/syserror.cpp" \
   "src/util/url.cpp" \
diff --git a/src/.clang-tidy b/src/.clang-tidy
index 5ac5710613093..76978140ecd72 100644
--- a/src/.clang-tidy
+++ b/src/.clang-tidy
@@ -1,16 +1,28 @@
 Checks: '
 -*,
 bugprone-argument-comment,
+bugprone-use-after-move,
+misc-unused-using-decls,
 modernize-use-default-member-init,
 modernize-use-nullptr,
+performance-for-range-copy,
+performance-move-const-arg,
+performance-unnecessary-copy-initialization,
 readability-const-return-type,
 readability-redundant-declaration,
 readability-redundant-string-init,
 '
 WarningsAsErrors: '
 bugprone-argument-comment,
+bugprone-use-after-move,
+misc-unused-using-decls,
 modernize-use-default-member-init,
 modernize-use-nullptr,
+performance-move-const-arg,
+performance-unnecessary-copy-initialization,
 readability-redundant-declaration,
 readability-redundant-string-init,
 '
+CheckOptions:
+ - key: performance-move-const-arg.CheckTriviallyCopyableMove
+   value: false
diff --git a/src/bench/load_external.cpp b/src/bench/load_external.cpp
index 68d7895f49b45..2d691484a3bda 100644
--- a/src/bench/load_external.cpp
+++ b/src/bench/load_external.cpp
@@ -28,7 +28,7 @@ static void LoadExternalBlockFile(benchmark::Bench& bench)
     // block data) as a stream object.
     const fs::path blkfile{testing_setup.get()->m_path_root / "blk.dat"};
     CDataStream ss(SER_DISK, 0);
-    auto params{Params()};
+    const auto& params{Params()};
     ss << params.MessageStart();
     ss << static_cast<uint32_t>(benchmark::data::block813851.size());
     // We can't use the streaming serialization (ss << benchmark::data::block813851)
diff --git a/src/bench/wallet_loading.cpp b/src/bench/wallet_loading.cpp
index 3d8700d5592ba..1a2bd7eceb326 100644
--- a/src/bench/wallet_loading.cpp
+++ b/src/bench/wallet_loading.cpp
@@ -19,8 +19,6 @@
 using wallet::CWallet;
 using wallet::DatabaseFormat;
 using wallet::DatabaseOptions;
-using wallet::ISMINE_SPENDABLE;
-using wallet::MakeWalletDatabase;
 using wallet::TxStateInactive;
 using wallet::WALLET_FLAG_DESCRIPTORS;
 using wallet::WalletContext;
diff --git a/src/bitcoin-cli.cpp b/src/bitcoin-cli.cpp
index 3e94ea5a26897..2f3b807131e99 100644
--- a/src/bitcoin-cli.cpp
+++ b/src/bitcoin-cli.cpp
@@ -948,7 +948,7 @@ static void GetWalletBalances(UniValue& result)
 
     UniValue balances(UniValue::VOBJ);
     for (const UniValue& wallet : wallets.getValues()) {
-        const std::string wallet_name = wallet.get_str();
+        const std::string& wallet_name = wallet.get_str();
         const UniValue getbalances = ConnectAndCallRPC(&rh, "getbalances", /* args=*/{}, wallet_name);
         const UniValue& balance = getbalances.find_value("result")["mine"]["trusted"];
         balances.pushKV(wallet_name, balance);
diff --git a/src/bitcoin-tx.cpp b/src/bitcoin-tx.cpp
index 9c9ccdae59dcd..f256516e2c082 100644
--- a/src/bitcoin-tx.cpp
+++ b/src/bitcoin-tx.cpp
@@ -555,7 +555,7 @@ static void MutateTxSign(CMutableTransaction& tx, const std::string& flagStr)
     UniValue prevtxsObj = registers["prevtxs"];
     {
         for (unsigned int previdx = 0; previdx < prevtxsObj.size(); previdx++) {
-            UniValue prevOut = prevtxsObj[previdx];
+            const UniValue& prevOut = prevtxsObj[previdx];
             if (!prevOut.isObject())
                 throw std::runtime_error("expected prevtxs internal object");
 
diff --git a/src/blockfilter.cpp b/src/blockfilter.cpp
index f4638dabcc0d1..364ed1c7ec728 100644
--- a/src/blockfilter.cpp
+++ b/src/blockfilter.cpp
@@ -170,7 +170,7 @@ const std::set<BlockFilterType>& AllBlockFilterTypes()
 
     static std::once_flag flag;
     std::call_once(flag, []() {
-            for (auto entry : g_filter_types) {
+            for (const auto& entry : g_filter_types) {
                 types.insert(entry.first);
             }
         });
diff --git a/src/bls/bls_worker.cpp b/src/bls/bls_worker.cpp
index 1a65899be450b..44f15e46c22b8 100644
--- a/src/bls/bls_worker.cpp
+++ b/src/bls/bls_worker.cpp
@@ -15,7 +15,7 @@ template <typename T>
 bool VerifyVectorHelper(Span<T> vec)
 {
     std::set<uint256> set;
-    for (auto item : vec) {
+    for (const auto& item : vec) {
         if (!item.IsValid())
             return false;
         // check duplicates
diff --git a/src/coins.cpp b/src/coins.cpp
index 0aa3bf708484b..d43e886b7603b 100644
--- a/src/coins.cpp
+++ b/src/coins.cpp
@@ -356,7 +356,7 @@ bool CCoinsViewErrorCatcher::GetCoin(const COutPoint &outpoint, Coin &coin) cons
     try {
         return CCoinsViewBacked::GetCoin(outpoint, coin);
     } catch(const std::runtime_error& e) {
-        for (auto f : m_err_callbacks) {
+        for (const auto& f : m_err_callbacks) {
             f();
         }
         LogPrintf("Error reading from database: %s\n", e.what());
diff --git a/src/core_read.cpp b/src/core_read.cpp
index 9f7c198d3f9e2..a6e362603aac5 100644
--- a/src/core_read.cpp
+++ b/src/core_read.cpp
@@ -189,7 +189,7 @@ int ParseSighashString(const UniValue& sighash)
             {std::string("SINGLE"), int(SIGHASH_SINGLE)},
             {std::string("SINGLE|ANYONECANPAY"), int(SIGHASH_SINGLE|SIGHASH_ANYONECANPAY)},
         };
-        std::string strHashType = sighash.get_str();
+        const std::string& strHashType = sighash.get_str();
         const auto& it = map_sighash_values.find(strHashType);
         if (it != map_sighash_values.end()) {
             hash_type = it->second;
diff --git a/src/evo/creditpool.cpp b/src/evo/creditpool.cpp
index 7a82653b4bc51..772ac70630ac8 100644
--- a/src/evo/creditpool.cpp
+++ b/src/evo/creditpool.cpp
@@ -91,7 +91,7 @@ static std::optional<CreditPoolDataPerBlock> GetCreditDataFromBlock(const gsl::n
         LogPrintf("%s: WARNING: No valid CbTx at height=%d\n", __func__, block_index->nHeight);
         return std::nullopt;
     }
-    for (CTransactionRef tx : block.vtx) {
+    for (const CTransactionRef& tx : block.vtx) {
         if (!tx->IsSpecialTxVersion() || tx->nType != TRANSACTION_ASSET_UNLOCK) continue;
 
         CAmount unlocked{0};
diff --git a/src/evo/mnauth.cpp b/src/evo/mnauth.cpp
index 376c96ecfaf40..ab04c18d3e40f 100644
--- a/src/evo/mnauth.cpp
+++ b/src/evo/mnauth.cpp
@@ -36,9 +36,7 @@ void CMNAuth::PushMNAUTH(CNode& peer, CConnman& connman, const CActiveMasternode
     if (Params().NetworkIDString() != CBaseChainParams::MAIN && gArgs.IsArgSet("-pushversion")) {
         nOurNodeVersion = gArgs.GetIntArg("-pushversion", PROTOCOL_VERSION);
     }
-    auto pk = mn_activeman.GetPubKey();
-    const CBLSPublicKey pubKey(pk);
-    const uint256 signHash{::SerializeHash(std::make_tuple(pubKey, receivedMNAuthChallenge, peer.IsInboundConn(), nOurNodeVersion))};
+    const uint256 signHash{::SerializeHash(std::make_tuple(mn_activeman.GetPubKey(), receivedMNAuthChallenge, peer.IsInboundConn(), nOurNodeVersion))};
 
     mnauth.proRegTxHash = mn_activeman.GetProTxHash();
 
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index a788bc22437fb..ba3a8ce8e2128 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -505,7 +505,7 @@ bool CSpecialTxProcessor::RebuildListFromBlock(const CBlock& block, gsl::not_nul
         newList.UpdateMN(dmn.proTxHash, newState);
     });
 
-    mnListRet = std::move(newList);
+    mnListRet = newList;
 
     return true;
 }
diff --git a/src/init.cpp b/src/init.cpp
index 642df953f34f3..c831ed4986a81 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -1440,7 +1440,7 @@ bool AppInitParameterInteraction(const ArgsManager& args)
 static bool LockDataDirectory(bool probeOnly)
 {
     // Make sure only a single Dash Core process is using the data directory.
-    fs::path datadir = gArgs.GetDataDirNet();
+    const fs::path& datadir = gArgs.GetDataDirNet();
     if (!DirIsWritable(datadir)) {
         return InitError(strprintf(_("Cannot write to data directory '%s'; check permissions."), fs::PathToString(datadir)));
     }
diff --git a/src/instantsend/instantsend.cpp b/src/instantsend/instantsend.cpp
index 0415a19d53776..fec6c4a6cd722 100644
--- a/src/instantsend/instantsend.cpp
+++ b/src/instantsend/instantsend.cpp
@@ -101,7 +101,7 @@ instantsend::PendingState CInstantSendManager::FetchPendingLocks()
     std::vector<uint256> removed;
     removed.reserve(std::min(maxCount, pendingInstantSendLocks.size()));
 
-    for (const auto& [islockHash, nodeid_islptr_pair] : pendingInstantSendLocks) {
+    for (auto& [islockHash, nodeid_islptr_pair] : pendingInstantSendLocks) {
         // Check if we've reached max count
         if (ret.m_pending_is.size() >= maxCount) {
             ret.m_pending_work = true;
diff --git a/src/llmq/blockprocessor.cpp b/src/llmq/blockprocessor.cpp
index 0baf23fb9abff..4fc57aba77de1 100644
--- a/src/llmq/blockprocessor.cpp
+++ b/src/llmq/blockprocessor.cpp
@@ -441,7 +441,7 @@ bool CQuorumBlockProcessor::GetCommitmentsFromBlock(const CBlock& block, gsl::no
 
     for (const auto& tx : block.vtx) {
         if (tx->nType == TRANSACTION_QUORUM_COMMITMENT) {
-            const auto opt_qc = GetTxPayload<CFinalCommitmentTxPayload>(*tx);
+            auto opt_qc = GetTxPayload<CFinalCommitmentTxPayload>(*tx);
             if (!opt_qc) {
                 // should not happen as it was verified before processing the block
                 LogPrint(BCLog::LLMQ, "CQuorumBlockProcessor::%s height=%d GetTxPayload fails\n", __func__, pindex->nHeight);
diff --git a/src/llmq/snapshot.cpp b/src/llmq/snapshot.cpp
index 123ad4c901941..cf744f6c781a4 100644
--- a/src/llmq/snapshot.cpp
+++ b/src/llmq/snapshot.cpp
@@ -209,17 +209,16 @@ bool BuildQuorumRotationInfo(CDeterministicMNManager& dmnman, CQuorumSnapshotMan
             response.quorumSnapshotAtHMinus4C = std::move(snapshotHMinus4C.value());
         }
 
-        CSimplifiedMNListDiff mn4c;
         if (!BuildSimplifiedMNListDiff(dmnman, chainman, qblockman, qman,
                                        GetLastBaseBlockHash(baseBlockIndexes, pWorkBlockHMinus4CIndex,
                                                             use_legacy_construction),
-                                       pWorkBlockHMinus4CIndex->GetBlockHash(), mn4c, errorRet)) {
+                                       pWorkBlockHMinus4CIndex->GetBlockHash(), response.mnListDiffAtHMinus4C, errorRet)) {
+            response.mnListDiffAtHMinus4C = {};
             return false;
         }
         if (!use_legacy_construction) {
             baseBlockIndexes.push_back(pWorkBlockHMinus4CIndex);
         }
-        response.mnListDiffAtHMinus4C = std::move(mn4c);
     } else {
         response.extraShare = false;
     }
diff --git a/src/logging.cpp b/src/logging.cpp
index 293ac4463d347..d59d1a86aa9b6 100644
--- a/src/logging.cpp
+++ b/src/logging.cpp
@@ -462,7 +462,7 @@ void BCLog::Logger::LogPrintStr(const std::string& str, const std::string& loggi
     }
 
     if (m_log_threadnames && m_started_new_line) {
-        const auto threadname = util::ThreadGetInternalName();
+        const auto& threadname = util::ThreadGetInternalName();
         // 16 chars total, "dash-" is 5 of them and another 1 is a NUL terminator
         str_prefixed.insert(0, "[" + strprintf("%10s", (threadname.empty() ? "unknown" : threadname)) + "] ");
     }
diff --git a/src/masternode/meta.cpp b/src/masternode/meta.cpp
index dee9c08397dc7..33b84f56c756c 100644
--- a/src/masternode/meta.cpp
+++ b/src/masternode/meta.cpp
@@ -150,7 +150,7 @@ std::optional<PlatformBanMessage> CMasternodeMetaMan::GetPlatformBan(const uint2
 void CMasternodeMetaMan::RememberPlatformBan(const uint256& inv_hash, PlatformBanMessage&& msg)
 {
     LOCK(cs);
-    m_seen_platform_bans.insert(inv_hash, std::move(msg));
+    m_seen_platform_bans.emplace(inv_hash, std::move(msg));
 }
 
 void CMasternodeMetaMan::AddUsedMasternode(const uint256& proTxHash)
diff --git a/src/netbase.cpp b/src/netbase.cpp
index 7ac84ad4e3d0e..b1a4f77500768 100644
--- a/src/netbase.cpp
+++ b/src/netbase.cpp
@@ -390,7 +390,7 @@ bool Socks5(const std::string& strDest, uint16_t port, const ProxyCredentials* a
         return error("Error sending to proxy");
     }
     uint8_t pchRet1[2];
-    if ((recvr = InterruptibleRecv(pchRet1, 2, g_socks5_recv_timeout, sock)) != IntrRecvError::OK) {
+    if (InterruptibleRecv(pchRet1, 2, g_socks5_recv_timeout, sock) != IntrRecvError::OK) {
         LogPrintf("Socks5() connect to %s:%d failed: InterruptibleRecv() timeout or other failure\n", strDest, port);
         return false;
     }
@@ -413,7 +413,7 @@ bool Socks5(const std::string& strDest, uint16_t port, const ProxyCredentials* a
         }
         LogPrint(BCLog::PROXY, "SOCKS5 sending proxy authentication %s:%s\n", auth->username, auth->password);
         uint8_t pchRetA[2];
-        if ((recvr = InterruptibleRecv(pchRetA, 2, g_socks5_recv_timeout, sock)) != IntrRecvError::OK) {
+        if (InterruptibleRecv(pchRetA, 2, g_socks5_recv_timeout, sock) != IntrRecvError::OK) {
             return error("Error reading proxy authentication response");
         }
         if (pchRetA[0] != 0x01 || pchRetA[1] != 0x00) {
@@ -479,7 +479,7 @@ bool Socks5(const std::string& strDest, uint16_t port, const ProxyCredentials* a
     if (recvr != IntrRecvError::OK) {
         return error("Error reading from proxy");
     }
-    if ((recvr = InterruptibleRecv(pchRet3, 2, g_socks5_recv_timeout, sock)) != IntrRecvError::OK) {
+    if (InterruptibleRecv(pchRet3, 2, g_socks5_recv_timeout, sock) != IntrRecvError::OK) {
         return error("Error reading from proxy");
     }
     LogPrint(BCLog::NET, "SOCKS5 connected %s\n", strDest);
diff --git a/src/node/blockstorage.cpp b/src/node/blockstorage.cpp
index 707acd044c289..76fd09843ac71 100644
--- a/src/node/blockstorage.cpp
+++ b/src/node/blockstorage.cpp
@@ -448,7 +448,7 @@ void CleanupBlockRevFiles()
     // Remove the rev files immediately and insert the blk file paths into an
     // ordered map keyed by block file index.
     LogPrintf("Removing unusable blk?????.dat and rev?????.dat files for -reindex with -prune\n");
-    fs::path blocksdir = gArgs.GetBlocksDirPath();
+    const fs::path& blocksdir = gArgs.GetBlocksDirPath();
     for (fs::directory_iterator it(blocksdir); it != fs::directory_iterator(); it++) {
         const std::string path = fs::PathToString(it->path().filename());
         if (fs::is_regular_file(*it) &&
diff --git a/src/qt/governancelist.cpp b/src/qt/governancelist.cpp
index 49c6abe6e6289..37f61fca4a066 100644
--- a/src/qt/governancelist.cpp
+++ b/src/qt/governancelist.cpp
@@ -43,23 +43,23 @@ Proposal::Proposal(ClientModel* _clientModel, const CGovernanceObject& _govObj,
 {
     UniValue prop_data;
     if (prop_data.read(govObj.GetDataAsPlainString())) {
-        if (UniValue titleValue = prop_data.find_value("name"); titleValue.isStr()) {
+        if (const UniValue& titleValue = prop_data.find_value("name"); titleValue.isStr()) {
             m_title = QString::fromStdString(titleValue.get_str());
         }
 
-        if (UniValue paymentStartValue = prop_data.find_value("start_epoch"); paymentStartValue.isNum()) {
+        if (const UniValue& paymentStartValue = prop_data.find_value("start_epoch"); paymentStartValue.isNum()) {
             m_startDate = QDateTime::fromSecsSinceEpoch(paymentStartValue.getInt<int64_t>());
         }
 
-        if (UniValue paymentEndValue = prop_data.find_value("end_epoch"); paymentEndValue.isNum()) {
+        if (const UniValue& paymentEndValue = prop_data.find_value("end_epoch"); paymentEndValue.isNum()) {
             m_endDate = QDateTime::fromSecsSinceEpoch(paymentEndValue.getInt<int64_t>());
         }
 
-        if (UniValue amountValue = prop_data.find_value("payment_amount"); amountValue.isNum()) {
+        if (const UniValue& amountValue = prop_data.find_value("payment_amount"); amountValue.isNum()) {
             m_paymentAmount = amountValue.get_real();
         }
 
-        if (UniValue urlValue = prop_data.find_value("url"); urlValue.isStr()) {
+        if (const UniValue& urlValue = prop_data.find_value("url"); urlValue.isStr()) {
             m_url = QString::fromStdString(urlValue.get_str());
         }
     }
diff --git a/src/qt/splashscreen.cpp b/src/qt/splashscreen.cpp
index cb92b6d9e2f54..f82f71c2c2647 100644
--- a/src/qt/splashscreen.cpp
+++ b/src/qt/splashscreen.cpp
@@ -55,7 +55,7 @@ SplashScreen::SplashScreen(const NetworkStyle *networkStyle) :
     // define text to place
     QString titleText       = PACKAGE_NAME;
     QString versionText = QString::fromStdString(FormatFullVersion()).remove(0, 1);
-    QString titleAddText    = networkStyle->getTitleAddText();
+    const QString& titleAddText = networkStyle->getTitleAddText();
 
     QFont fontNormal = GUIUtil::getFontNormal();
     QFont fontBold = GUIUtil::getFontBold();
@@ -116,8 +116,7 @@ SplashScreen::SplashScreen(const NetworkStyle *networkStyle) :
         int titleAddTextWidth = GUIUtil::TextWidth(fm, titleAddText);
         // Draw the badge background with the network-specific color
         QRect badgeRect = QRect(width - titleAddTextWidth - 20, 5, width, fm.height() + 10);
-        QColor badgeColor = networkStyle->getBadgeColor();
-        pixPaint.fillRect(badgeRect, badgeColor);
+        pixPaint.fillRect(badgeRect, networkStyle->getBadgeColor());
         // Draw the text itself using white color, regardless of the current theme
         pixPaint.setPen(QColor(255, 255, 255));
         pixPaint.drawText(width - titleAddTextWidth - 10, paddingTop + 10, titleAddText);
diff --git a/src/qt/transactionrecord.cpp b/src/qt/transactionrecord.cpp
index 0e550eb1bf9e3..3814cd9c19999 100644
--- a/src/qt/transactionrecord.cpp
+++ b/src/qt/transactionrecord.cpp
@@ -13,7 +13,6 @@
 
 #include <cstdint>
 
-using wallet::ISMINE_ALL;
 using wallet::ISMINE_SPENDABLE;
 using wallet::ISMINE_WATCH_ONLY;
 using wallet::isminetype;
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index fbb893e637f2f..8401e186c750f 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -2527,7 +2527,7 @@ static RPCHelpMan scantxoutset()
         for (const UniValue& scanobject : request.params[1].get_array().getValues()) {
             FlatSigningProvider provider;
             auto scripts = EvalDescriptorStringOrObject(scanobject, provider);
-            for (const auto& script : scripts) {
+            for (CScript& script : scripts) {
                 std::string inferred = InferDescriptor(script, provider)->ToString();
                 needles.emplace(script);
                 descriptors.emplace(std::move(script), std::move(inferred));
diff --git a/src/rpc/coinjoin.cpp b/src/rpc/coinjoin.cpp
index 0c9b16bd634bf..d3dd399dd35d4 100644
--- a/src/rpc/coinjoin.cpp
+++ b/src/rpc/coinjoin.cpp
@@ -173,7 +173,7 @@ static RPCHelpMan coinjoin_status()
     }
 
     UniValue ret(UniValue::VARR);
-    for (auto str_status : cj_clientman->getSessionStatuses()) {
+    for (const auto& str_status : cj_clientman->getSessionStatuses()) {
         ret.push_back(str_status);
     }
     return ret;
diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
index 12bd74cc79ddc..8f675c7336ab1 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -50,8 +50,6 @@ using node::NodeContext;
 using wallet::CWallet;
 #ifdef ENABLE_WALLET
 using wallet::CCoinControl;
-using wallet::CoinType;
-using wallet::COutput;
 using wallet::CRecipient;
 using wallet::DEFAULT_DISABLE_WALLET;
 using wallet::GetWalletForJSONRPCRequest;
diff --git a/src/rpc/masternode.cpp b/src/rpc/masternode.cpp
index 3ea189ebbc28a..7a8537da33563 100644
--- a/src/rpc/masternode.cpp
+++ b/src/rpc/masternode.cpp
@@ -36,7 +36,6 @@ using node::ReadBlockFromDisk;
 #ifdef ENABLE_WALLET
 using wallet::CCoinControl;
 using wallet::CoinType;
-using wallet::COutput;
 using wallet::CWallet;
 using wallet::GetWalletForJSONRPCRequest;
 #endif // ENABLE_WALLET
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 11e6cd906d451..6e372c75cea03 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -131,7 +131,7 @@ static bool GenerateBlock(ChainstateManager& chainman, CBlock& block, uint64_t&
     block_hash.SetNull();
     block.hashMerkleRoot = BlockMerkleRoot(block);
 
-    CChainParams chainparams(Params());
+    const CChainParams& chainparams(Params());
 
     while (max_tries > 0 && block.nNonce < std::numeric_limits<uint32_t>::max() && !CheckProofOfWork(block.GetHash(), block.nBits, chainparams.GetConsensus()) && !ShutdownRequested()) {
         ++block.nNonce;
@@ -356,7 +356,7 @@ static RPCHelpMan generateblock()
         }
     }
 
-    CChainParams chainparams(Params());
+    const CChainParams& chainparams(Params());
     const LLMQContext& llmq_ctx = EnsureLLMQContext(node);
 
     ChainstateManager& chainman = EnsureChainman(node);
@@ -755,7 +755,7 @@ static RPCHelpMan getblocktemplate()
         if (lpval.isStr())
         {
             // Format: <hashBestChain><nTransactionsUpdatedLast>
-            std::string lpstr = lpval.get_str();
+            const std::string& lpstr = lpval.get_str();
 
             hashWatchedChain = ParseHashV(lpstr.substr(0, 64), "longpollid");
             nTransactionsUpdatedLastLP = LocaleIndependentAtoi<int64_t>(lpstr.substr(64));
diff --git a/src/rpc/output_script.cpp b/src/rpc/output_script.cpp
index ad26dd77c168f..ca5beef1d0f71 100644
--- a/src/rpc/output_script.cpp
+++ b/src/rpc/output_script.cpp
@@ -23,11 +23,6 @@
 #include <string>
 #include <vector>
 
-namespace node {
-struct NodeContext;
-}
-using node::NodeContext;
-
 static RPCHelpMan validateaddress()
 {
     return RPCHelpMan{
diff --git a/src/rpc/rawtransaction_util.cpp b/src/rpc/rawtransaction_util.cpp
index e66a5b2d3aa94..8ab727004650a 100644
--- a/src/rpc/rawtransaction_util.cpp
+++ b/src/rpc/rawtransaction_util.cpp
@@ -146,14 +146,14 @@ static void TxInErrorToJSON(const CTxIn& txin, UniValue& vErrorsRet, const std::
 void ParsePrevouts(const UniValue& prevTxsUnival, FillableSigningProvider* keystore, std::map<COutPoint, Coin>& coins)
 {
     if (!prevTxsUnival.isNull()) {
-        UniValue prevTxs = prevTxsUnival.get_array();
+        const UniValue& prevTxs = prevTxsUnival.get_array();
         for (unsigned int idx = 0; idx < prevTxs.size(); ++idx) {
             const UniValue& p = prevTxs[idx];
             if (!p.isObject()) {
                 throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "expected object with {\"txid'\",\"vout\",\"scriptPubKey\"}");
             }
 
-            UniValue prevOut = p.get_obj();
+            const UniValue& prevOut = p.get_obj();
 
             RPCTypeCheckObj(prevOut,
                 {
diff --git a/src/rpc/util.cpp b/src/rpc/util.cpp
index da552c410f5f4..3f3b852422f19 100644
--- a/src/rpc/util.cpp
+++ b/src/rpc/util.cpp
@@ -99,7 +99,7 @@ CAmount AmountFromValue(const UniValue& value, int decimals)
 
 uint256 ParseHashV(const UniValue& v, std::string strName)
 {
-    std::string strHex{v.get_str()};
+    const std::string& strHex(v.get_str());
     if (64 != strHex.length())
         throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("%s must be of length %d (not %d, for '%s')", strName, 64, strHex.length(), strHex));
     if (!IsHex(strHex)) // Note: IsHex("") is false
@@ -126,7 +126,7 @@ std::vector<unsigned char> ParseHexO(const UniValue& o, std::string strKey)
 
 int32_t ParseInt32V(const UniValue& v, const std::string &strName)
 {
-    std::string strNum = v.getValStr();
+    const std::string& strNum = v.getValStr();
     int32_t num;
     if (!ParseInt32(strNum, &num))
         throw JSONRPCError(RPC_INVALID_PARAMETER, strName+" must be a 32bit integer (not '"+strNum+"')");
@@ -135,7 +135,7 @@ int32_t ParseInt32V(const UniValue& v, const std::string &strName)
 
 int64_t ParseInt64V(const UniValue& v, const std::string &strName)
 {
-    std::string strNum = v.getValStr();
+    const std::string& strNum = v.getValStr();
     int64_t num;
     if (!ParseInt64(strNum, &num))
         throw JSONRPCError(RPC_INVALID_PARAMETER, strName+" must be a 64bit integer (not '"+strNum+"')");
diff --git a/src/script/descriptor.cpp b/src/script/descriptor.cpp
index 1b84c6f580e89..49d14db91562d 100644
--- a/src/script/descriptor.cpp
+++ b/src/script/descriptor.cpp
@@ -547,7 +547,7 @@ class DescriptorImpl : public Descriptor
             if (pos++) ret += ",";
             std::string tmp;
             if (!scriptarg->ToStringHelper(arg, tmp, type, cache)) return false;
-            ret += std::move(tmp);
+            ret += tmp;
         }
         return true;
     }
@@ -571,7 +571,7 @@ class DescriptorImpl : public Descriptor
                     tmp = pubkey->ToString();
                     break;
             }
-            ret += std::move(tmp);
+            ret += tmp;
         }
         std::string subscript;
         if (!ToStringSubScriptHelper(arg, subscript, type, cache)) return false;
diff --git a/src/test/base58_tests.cpp b/src/test/base58_tests.cpp
index fbe873ef3237a..2cd1ae9510d2a 100644
--- a/src/test/base58_tests.cpp
+++ b/src/test/base58_tests.cpp
@@ -24,7 +24,7 @@ BOOST_AUTO_TEST_CASE(base58_EncodeBase58)
 {
     UniValue tests = read_json(std::string(json_tests::base58_encode_decode, json_tests::base58_encode_decode + sizeof(json_tests::base58_encode_decode)));
     for (unsigned int idx = 0; idx < tests.size(); idx++) {
-        UniValue test = tests[idx];
+        const UniValue& test = tests[idx];
         std::string strTest = test.write();
         if (test.size() < 2) // Allow for extra stuff (useful for comments)
         {
@@ -46,7 +46,7 @@ BOOST_AUTO_TEST_CASE(base58_DecodeBase58)
     std::vector<unsigned char> result;
 
     for (unsigned int idx = 0; idx < tests.size(); idx++) {
-        UniValue test = tests[idx];
+        const UniValue& test = tests[idx];
         std::string strTest = test.write();
         if (test.size() < 2) // Allow for extra stuff (useful for comments)
         {
diff --git a/src/test/blockfilter_tests.cpp b/src/test/blockfilter_tests.cpp
index 54ab568e7d3a0..b33cca1377384 100644
--- a/src/test/blockfilter_tests.cpp
+++ b/src/test/blockfilter_tests.cpp
@@ -144,7 +144,7 @@ BOOST_AUTO_TEST_CASE(blockfilters_json_test)
 
     const UniValue& tests = json.get_array();
     for (unsigned int i = 0; i < tests.size(); i++) {
-        UniValue test = tests[i];
+        const UniValue& test = tests[i];
         std::string strTest = test.write();
 
         if (test.size() == 1) {
diff --git a/src/test/coinstatsindex_tests.cpp b/src/test/coinstatsindex_tests.cpp
index e3335373231f9..b8f5a2b4b9f0f 100644
--- a/src/test/coinstatsindex_tests.cpp
+++ b/src/test/coinstatsindex_tests.cpp
@@ -12,9 +12,6 @@
 
 #include <boost/test/unit_test.hpp>
 
-using kernel::CCoinsStats;
-using kernel::CoinStatsHashType;
-
 BOOST_AUTO_TEST_SUITE(coinstatsindex_tests)
 
 BOOST_FIXTURE_TEST_CASE(coinstatsindex_initial_sync, TestChain100Setup)
diff --git a/src/test/evo_deterministicmns_tests.cpp b/src/test/evo_deterministicmns_tests.cpp
index c67d4dd407258..8d27e75aec0ff 100644
--- a/src/test/evo_deterministicmns_tests.cpp
+++ b/src/test/evo_deterministicmns_tests.cpp
@@ -886,8 +886,9 @@ static void SmlCache(TestChainSetup& setup)
     CDeterministicMNList mn_list_1(emptyList);
     BOOST_CHECK(sml_empty == mn_list_1.to_sml());
 
+    CDeterministicMNList mn_list_2;
     // Assigning list should return the same cached object
-    CDeterministicMNList mn_list_2 = emptyList;
+    mn_list_2 = emptyList;
     BOOST_CHECK(sml_empty == mn_list_2.to_sml());
 
     auto dmn = create_mock_mn(1);
diff --git a/src/test/evo_trivialvalidation.cpp b/src/test/evo_trivialvalidation.cpp
index 55312417d9ef1..df076eadca219 100644
--- a/src/test/evo_trivialvalidation.cpp
+++ b/src/test/evo_trivialvalidation.cpp
@@ -48,7 +48,7 @@ void trivialvalidation_runner(const CChain& active_chain, const std::string& jso
     const UniValue vectors = read_json(json);
 
     for (size_t idx = 1; idx < vectors.size(); idx++) {
-        UniValue test = vectors[idx];
+        const UniValue& test = vectors[idx];
         uint256 txHash;
         std::string txType;
         CMutableTransaction tx;
diff --git a/src/test/fuzz/txorphan.cpp b/src/test/fuzz/txorphan.cpp
index 25244771dfa95..1a279b6bb74cf 100644
--- a/src/test/fuzz/txorphan.cpp
+++ b/src/test/fuzz/txorphan.cpp
@@ -19,7 +19,6 @@
 #include <util/check.h>
 #include <util/time.h>
 
-#include <algorithm>
 #include <cstdint>
 #include <memory>
 #include <set>
@@ -69,7 +68,7 @@ FUZZ_TARGET(txorphan, .init = initialize_orphanage)
             for (uint32_t i = 0; i < num_out; i++) {
                 tx_mut.vout.emplace_back(CAmount{0}, CScript{});
             }
-            // restore previously poped outpoints
+            // restore previously popped outpoints
             for (auto& in : tx_mut.vin) {
                 outpoints.push_back(in.prevout);
             }
diff --git a/src/test/key_io_tests.cpp b/src/test/key_io_tests.cpp
index d01e4cb6fbe7c..827c6cc71e189 100644
--- a/src/test/key_io_tests.cpp
+++ b/src/test/key_io_tests.cpp
@@ -28,7 +28,7 @@ BOOST_AUTO_TEST_CASE(key_io_valid_parse)
     SelectParams(CBaseChainParams::MAIN);
 
     for (unsigned int idx = 0; idx < tests.size(); idx++) {
-        UniValue test = tests[idx];
+        const UniValue& test = tests[idx];
         std::string strTest = test.write();
         if (test.size() < 3) { // Allow for extra stuff (useful for comments)
             BOOST_ERROR("Bad test: " << strTest);
@@ -86,7 +86,7 @@ BOOST_AUTO_TEST_CASE(key_io_valid_gen)
     UniValue tests = read_json(std::string(json_tests::key_io_valid, json_tests::key_io_valid + sizeof(json_tests::key_io_valid)));
 
     for (unsigned int idx = 0; idx < tests.size(); idx++) {
-        UniValue test = tests[idx];
+        const UniValue& test = tests[idx];
         std::string strTest = test.write();
         if (test.size() < 3) // Allow for extra stuff (useful for comments)
         {
@@ -126,7 +126,7 @@ BOOST_AUTO_TEST_CASE(key_io_invalid)
     CTxDestination destination;
 
     for (unsigned int idx = 0; idx < tests.size(); idx++) {
-        UniValue test = tests[idx];
+        const UniValue& test = tests[idx];
         std::string strTest = test.write();
         if (test.size() < 1) // Allow for extra stuff (useful for comments)
         {
diff --git a/src/test/miniscript_tests.cpp b/src/test/miniscript_tests.cpp
index 3877fea907e88..46ed47b1d4803 100644
--- a/src/test/miniscript_tests.cpp
+++ b/src/test/miniscript_tests.cpp
@@ -116,6 +116,8 @@ struct KeyConverter {
 //! Singleton instance of KeyConverter.
 const KeyConverter CONVERTER{};
 
+// https://github.com/llvm/llvm-project/issues/53444
+// NOLINTNEXTLINE(misc-unused-using-decls)
 using miniscript::operator"" _mst;
 
 enum TestMode : int {
diff --git a/src/test/script_tests.cpp b/src/test/script_tests.cpp
index 06968ae7c5fd0..100f5300724cf 100644
--- a/src/test/script_tests.cpp
+++ b/src/test/script_tests.cpp
@@ -881,7 +881,7 @@ BOOST_AUTO_TEST_CASE(script_json_test)
     UniValue tests = read_json(std::string(json_tests::script_tests, json_tests::script_tests + sizeof(json_tests::script_tests)));
 
     for (unsigned int idx = 0; idx < tests.size(); idx++) {
-        UniValue test = tests[idx];
+        const UniValue& test = tests[idx];
         std::string strTest = test.write();
         if (test.size() < 4) // Allow size > 3; extra stuff ignored (useful for comments)
         {
diff --git a/src/test/sighash_tests.cpp b/src/test/sighash_tests.cpp
index 2a62c16c90d4c..f1d8e6d0ad909 100644
--- a/src/test/sighash_tests.cpp
+++ b/src/test/sighash_tests.cpp
@@ -161,7 +161,7 @@ BOOST_AUTO_TEST_CASE(sighash_from_data)
     UniValue tests = read_json(std::string(json_tests::sighash, json_tests::sighash + sizeof(json_tests::sighash)));
 
     for (unsigned int idx = 0; idx < tests.size(); idx++) {
-        UniValue test = tests[idx];
+        const UniValue& test = tests[idx];
         std::string strTest = test.write();
         if (test.size() < 1) // Allow for extra stuff (useful for comments)
         {
diff --git a/src/test/transaction_tests.cpp b/src/test/transaction_tests.cpp
index 5a61438d9dd0d..6e117ad5117b9 100644
--- a/src/test/transaction_tests.cpp
+++ b/src/test/transaction_tests.cpp
@@ -153,7 +153,7 @@ BOOST_AUTO_TEST_CASE(tx_valid)
     UniValue tests = read_json(std::string(json_tests::tx_valid, json_tests::tx_valid + sizeof(json_tests::tx_valid)));
 
     for (unsigned int idx = 0; idx < tests.size(); idx++) {
-        UniValue test = tests[idx];
+        const UniValue& test = tests[idx];
         std::string strTest = test.write();
         if (test[0].isArray())
         {
@@ -172,7 +172,7 @@ BOOST_AUTO_TEST_CASE(tx_valid)
                     fValid = false;
                     break;
                 }
-                UniValue vinput = input.get_array();
+                const UniValue& vinput = input.get_array();
                 if (vinput.size() != 3)
                 {
                     fValid = false;
@@ -237,7 +237,7 @@ BOOST_AUTO_TEST_CASE(tx_invalid)
     UniValue tests = read_json(std::string(json_tests::tx_invalid, json_tests::tx_invalid + sizeof(json_tests::tx_invalid)));
 
     for (unsigned int idx = 0; idx < tests.size(); idx++) {
-        UniValue test = tests[idx];
+        const UniValue& test = tests[idx];
         std::string strTest = test.write();
         if (test[0].isArray())
         {
@@ -256,7 +256,7 @@ BOOST_AUTO_TEST_CASE(tx_invalid)
                     fValid = false;
                     break;
                 }
-                UniValue vinput = input.get_array();
+                const UniValue& vinput = input.get_array();
                 if (vinput.size() != 3)
                 {
                     fValid = false;
diff --git a/src/test/util_tests.cpp b/src/test/util_tests.cpp
index ae2778ac56904..6d5c7be2c019c 100644
--- a/src/test/util_tests.cpp
+++ b/src/test/util_tests.cpp
@@ -1304,13 +1304,13 @@ BOOST_AUTO_TEST_CASE(test_tracked_vector)
 
     auto v2 = Vector(std::move(t2));
     BOOST_CHECK_EQUAL(v2.size(), 1U);
-    BOOST_CHECK(v2[0].origin == &t2);
+    BOOST_CHECK(v2[0].origin == &t2); // NOLINT(*-use-after-move)
     BOOST_CHECK_EQUAL(v2[0].copies, 0);
 
     auto v3 = Vector(t1, std::move(t2));
     BOOST_CHECK_EQUAL(v3.size(), 2U);
     BOOST_CHECK(v3[0].origin == &t1);
-    BOOST_CHECK(v3[1].origin == &t2);
+    BOOST_CHECK(v3[1].origin == &t2); // NOLINT(*-use-after-move)
     BOOST_CHECK_EQUAL(v3[0].copies, 1);
     BOOST_CHECK_EQUAL(v3[1].copies, 0);
 
@@ -1318,7 +1318,7 @@ BOOST_AUTO_TEST_CASE(test_tracked_vector)
     BOOST_CHECK_EQUAL(v4.size(), 3U);
     BOOST_CHECK(v4[0].origin == &t1);
     BOOST_CHECK(v4[1].origin == &t2);
-    BOOST_CHECK(v4[2].origin == &t3);
+    BOOST_CHECK(v4[2].origin == &t3); // NOLINT(*-use-after-move)
     BOOST_CHECK_EQUAL(v4[0].copies, 1);
     BOOST_CHECK_EQUAL(v4[1].copies, 1);
     BOOST_CHECK_EQUAL(v4[2].copies, 0);
diff --git a/src/test/validation_block_tests.cpp b/src/test/validation_block_tests.cpp
index 99a6109fee68c..9e83bdf6d3209 100644
--- a/src/test/validation_block_tests.cpp
+++ b/src/test/validation_block_tests.cpp
@@ -182,7 +182,7 @@ BOOST_AUTO_TEST_CASE(processnewblock_signals_ordering)
             }
 
             // to make sure that eventually we process the full chain - do it here
-            for (auto block : blocks) {
+            for (const auto& block : blocks) {
                 if (block->vtx.size() == 1) {
                     bool processed = Assert(m_node.chainman)->ProcessNewBlock(Params(), block, true, &ignored);
                     assert(processed);
diff --git a/src/univalue/include/univalue.h b/src/univalue/include/univalue.h
index 076fcfa43277f..d895b26af988b 100644
--- a/src/univalue/include/univalue.h
+++ b/src/univalue/include/univalue.h
@@ -77,14 +77,14 @@ class UniValue {
     bool isArray() const { return (typ == VARR); }
     bool isObject() const { return (typ == VOBJ); }
 
-    void push_back(const UniValue& val);
+    void push_back(UniValue val);
     void push_backV(const std::vector<UniValue>& vec);
     template <class It>
     void push_backV(It first, It last);
 
-    void __pushKV(const std::string& key, const UniValue& val);
-    void pushKV(const std::string& key, const UniValue& val);
-    void pushKVs(const UniValue& obj);
+    void __pushKV(std::string key, UniValue val);
+    void pushKV(std::string key, UniValue val);
+    void pushKVs(UniValue obj);
 
     std::string write(unsigned int prettyIndent = 0,
                       unsigned int indentLevel = 0) const;
diff --git a/src/univalue/lib/univalue.cpp b/src/univalue/lib/univalue.cpp
index 4c8066767a94e..29660ceedc466 100644
--- a/src/univalue/lib/univalue.cpp
+++ b/src/univalue/lib/univalue.cpp
@@ -101,11 +101,11 @@ void UniValue::setObject()
     typ = VOBJ;
 }
 
-void UniValue::push_back(const UniValue& val_)
+void UniValue::push_back(UniValue val)
 {
     checkType(VARR);
 
-    values.push_back(val_);
+    values.push_back(std::move(val));
 }
 
 void UniValue::push_backV(const std::vector<UniValue>& vec)
@@ -115,32 +115,32 @@ void UniValue::push_backV(const std::vector<UniValue>& vec)
     values.insert(values.end(), vec.begin(), vec.end());
 }
 
-void UniValue::__pushKV(const std::string& key, const UniValue& val_)
+void UniValue::__pushKV(std::string key, UniValue val)
 {
     checkType(VOBJ);
 
-    keys.push_back(key);
-    values.push_back(val_);
+    keys.push_back(std::move(key));
+    values.push_back(std::move(val));
 }
 
-void UniValue::pushKV(const std::string& key, const UniValue& val_)
+void UniValue::pushKV(std::string key, UniValue val)
 {
     checkType(VOBJ);
 
     size_t idx;
     if (findKey(key, idx))
-        values[idx] = val_;
+        values[idx] = std::move(val);
     else
-        __pushKV(key, val_);
+        __pushKV(std::move(key), std::move(val));
 }
 
-void UniValue::pushKVs(const UniValue& obj)
+void UniValue::pushKVs(UniValue obj)
 {
     checkType(VOBJ);
     obj.checkType(VOBJ);
 
     for (size_t i = 0; i < obj.keys.size(); i++)
-        __pushKV(obj.keys[i], obj.values.at(i));
+        __pushKV(std::move(obj.keys.at(i)), std::move(obj.values.at(i)));
 }
 
 void UniValue::getObjMap(std::map<std::string,UniValue>& kv) const
diff --git a/src/util/message.cpp b/src/util/message.cpp
index 685093bb12da0..2a723b3bf2085 100644
--- a/src/util/message.cpp
+++ b/src/util/message.cpp
@@ -8,7 +8,6 @@
 #include <key_io.h>
 #include <pubkey.h>
 #include <script/standard.h>
-#include <serialize.h>
 #include <uint256.h>
 #include <util/message.h>
 #include <util/strencodings.h>
diff --git a/src/util/strencodings.cpp b/src/util/strencodings.cpp
index a69c770ac1b9d..cbbbb5c9692b9 100644
--- a/src/util/strencodings.cpp
+++ b/src/util/strencodings.cpp
@@ -6,7 +6,6 @@
 #include <span.h>
 #include <util/strencodings.h>
 
-#include <algorithm>
 #include <array>
 #include <cassert>
 #include <cstring>
diff --git a/src/util/string.cpp b/src/util/string.cpp
index db6dbe4135b9d..e994c85f1c05c 100644
--- a/src/util/string.cpp
+++ b/src/util/string.cpp
@@ -6,10 +6,9 @@
 
 #include <regex>
 #include <string>
-#include <utility>
 
 void ReplaceAll(std::string& in_out, const std::string& search, const std::string& substitute)
 {
     if (search.empty()) return;
-    in_out = std::regex_replace(in_out, std::regex(std::move(search)), substitute);
+    in_out = std::regex_replace(in_out, std::regex(search), substitute);
 }
diff --git a/src/util/string.h b/src/util/string.h
index e87d0a6e02abb..f9b5ff3d87c67 100644
--- a/src/util/string.h
+++ b/src/util/string.h
@@ -7,7 +7,6 @@
 
 #include <util/spanparsing.h>
 
-#include <algorithm>
 #include <array>
 #include <cstdint>
 #include <cstring>
diff --git a/src/util/threadinterrupt.h b/src/util/threadinterrupt.h
index 4805e14eb3fe8..d95cbb9abadce 100644
--- a/src/util/threadinterrupt.h
+++ b/src/util/threadinterrupt.h
@@ -6,6 +6,7 @@
 #define BITCOIN_UTIL_THREADINTERRUPT_H
 
 #include <sync.h>
+#include <threadsafety.h>
 
 #include <atomic>
 #include <chrono>
diff --git a/src/wallet/bdb.cpp b/src/wallet/bdb.cpp
index 65fb838f655c5..c5c3870fd6fa1 100644
--- a/src/wallet/bdb.cpp
+++ b/src/wallet/bdb.cpp
@@ -443,7 +443,7 @@ void BerkeleyEnvironment::ReloadDbEnv()
     });
 
     std::vector<fs::path> filenames;
-    for (auto it : m_databases) {
+    for (const auto& it : m_databases) {
         filenames.push_back(it.first);
     }
     // Close the individual Db's
diff --git a/src/wallet/receive.cpp b/src/wallet/receive.cpp
index a5d0bcc599881..43bf3b6335296 100644
--- a/src/wallet/receive.cpp
+++ b/src/wallet/receive.cpp
@@ -428,7 +428,7 @@ std::set< std::set<CTxDestination> > GetAddressGroupings(const CWallet& wallet)
 
     std::set< std::set<CTxDestination>* > uniqueGroupings; // a set of pointers to groups of addresses
     std::map< CTxDestination, std::set<CTxDestination>* > setmap;  // map addresses to the unique group containing it
-    for (std::set<CTxDestination> _grouping : groupings)
+    for (const std::set<CTxDestination>& _grouping : groupings)
     {
         // make a set of all the groups hit by this new group
         std::set< std::set<CTxDestination>* > hits;
diff --git a/src/wallet/rpc/backup.cpp b/src/wallet/rpc/backup.cpp
index 055aceff5ea73..080b0f1e3b2ce 100644
--- a/src/wallet/rpc/backup.cpp
+++ b/src/wallet/rpc/backup.cpp
@@ -91,11 +91,13 @@ RPCHelpMan importprivkey()
         "Hint: use importmulti to import more than one private key.\n"
     "\nNote: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\n"
     "may report that the imported key exists but related transactions are still missing, leading to temporarily incorrect/bogus balances and unspent outputs until rescan completes.\n"
+    "The rescan parameter can be set to false if the key was never used to create transactions. If it is set to false,\n"
+    "but the key was used to create transactions, rescanwallet needs to be called with the appropriate block range.\n"
     "Note: This command is only compatible with legacy wallets. Use \"importdescriptors\" with \"combo(X)\" for descriptor wallets.\n",
         {
             {"privkey", RPCArg::Type::STR, RPCArg::Optional::NO, "The private key (see dumpprivkey)"},
             {"label", RPCArg::Type::STR, RPCArg::DefaultHint{"current label if address exists, otherwise \"\""}, "An optional label"},
-            {"rescan", RPCArg::Type::BOOL, RPCArg::Default{true}, "Rescan the wallet for transactions"},
+            {"rescan", RPCArg::Type::BOOL, RPCArg::Default{true}, "Scan the chain and mempool for wallet transactions."},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{
@@ -208,6 +210,8 @@ RPCHelpMan importaddress()
     "\nAdds an address or script (in hex) that can be watched as if it were in your wallet but cannot be used to spend. Requires a new wallet backup.\n"
     "\nNote: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\n"
     "may report that the imported address exists but related transactions are still missing, leading to temporarily incorrect/bogus balances and unspent outputs until rescan completes.\n"
+    "The rescan parameter can be set to false if the key was never used to create transactions. If it is set to false,\n"
+    "but the key was used to create transactions, rescanwallet needs to be called with the appropriate block range.\n"
     "If you have the full public key, you should call importpubkey instead of this.\n"
     "Hint: use importmulti to import more than one address.\n"
     "\nNote: If you import a non-standard raw script in hex form, outputs sending to it will be treated\n"
@@ -216,7 +220,7 @@ RPCHelpMan importaddress()
     {
             {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The Dash address (or hex-encoded script)"},
             {"label", RPCArg::Type::STR, RPCArg::Default{""}, "An optional label"},
-            {"rescan", RPCArg::Type::BOOL, RPCArg::Default{true}, "Rescan the wallet for transactions"},
+            {"rescan", RPCArg::Type::BOOL, RPCArg::Default{true}, "Scan the chain and mempool for wallet transactions."},
             {"p2sh", RPCArg::Type::BOOL, RPCArg::Default{false}, "Add the P2SH version of the script as well"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
@@ -404,11 +408,13 @@ RPCHelpMan importpubkey()
         "Hint: use importmulti to import more than one public key.\n"
     "\nNote: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\n"
     "may report that the imported pubkey exists but related transactions are still missing, leading to temporarily incorrect/bogus balances and unspent outputs until rescan completes.\n"
+    "The rescan parameter can be set to false if the key was never used to create transactions. If it is set to false,\n"
+    "but the key was used to create transactions, rescanwallet needs to be called with the appropriate block range.\n"
     "Note: This command is only compatible with legacy wallets. Use \"importdescriptors\" with \"combo(X)\" for descriptor wallets.\n",
         {
             {"pubkey", RPCArg::Type::STR, RPCArg::Optional::NO, "The hex-encoded public key"},
             {"label", RPCArg::Type::STR, RPCArg::Default{""}, "An optional label"},
-            {"rescan", RPCArg::Type::BOOL, RPCArg::Default{true}, "Rescan the wallet for transactions"},
+            {"rescan", RPCArg::Type::BOOL, RPCArg::Default{true}, "Scan the chain and mempool for wallet transactions."},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{
@@ -484,7 +490,7 @@ RPCHelpMan importwallet()
 {
     return RPCHelpMan{"importwallet",
         "\nImports keys from a wallet dump file (see dumpwallet). Requires a new wallet backup to include imported keys.\n"
-        "Note: Use \"getwalletinfo\" to query the scanning progress.\n"
+        "Note: Blockchain and Mempool will be rescanned after a successful import. Use \"getwalletinfo\" to query the scanning progress.\n"
         "Note: This command is only compatible with legacy wallets.\n",
         {
             {"filename", RPCArg::Type::STR, RPCArg::Optional::NO, "The wallet file"},
@@ -1475,6 +1481,8 @@ RPCHelpMan importmulti()
         "\nImport addresses/scripts (with private or public keys, redeem script (P2SH)), optionally rescanning the blockchain from the earliest creation time of the imported scripts. Requires a new wallet backup.\n"
         "If an address/script is imported without all of the private keys required to spend from that address, it will be watchonly. The 'watchonly' option must be set to true in this case or a warning will be returned.\n"
         "Conversely, if all the private keys are provided and the address/script is spendable, the watchonly option must be set to false, or a warning will be returned.\n"
+        "The rescan parameter can be set to false if the key was never used to create transactions. If it is set to false,\n"
+        "but the key was used to create transactions, rescanwallet needs to be called with the appropriate block range.\n"
         "\nNote: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\n"
         "may report that the imported keys, addresses or scripts exists but related transactions are still missing.\n"
         "Note: This command is only compatible with legacy wallets. Use \"importdescriptors\" for descriptor wallets.\n",
@@ -1518,7 +1526,7 @@ RPCHelpMan importmulti()
                 "\"requests\""},
             {"options", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED_NAMED_ARG, "",
                 {
-                    {"rescan", RPCArg::Type::BOOL, RPCArg::Default{true}, "Stating if should rescan the blockchain after all imports"},
+                    {"rescan", RPCArg::Type::BOOL, RPCArg::Default{true}, "Scan the chain and mempool for wallet transactions after all imports."},
                 },
                 "\"options\""},
         },
@@ -1830,7 +1838,7 @@ RPCHelpMan importdescriptors() {
         "                                                              Use the string \"now\" to substitute the current synced blockchain time.\n"
         "                                                              \"now\" can be specified to bypass scanning, for outputs which are known to never have been used, and\n"
         "                                                              0 can be specified to scan the entire blockchain. Blocks up to 2 hours before the earliest timestamp\n"
-        "                                                              of all descriptors being imported will be scanned.",
+        "                                                              of all descriptors being imported will be scanned as well as the mempool.",
                                         /*oneline_description=*/"", {"timestamp | \"now\"", "integer / string"}
                                     },
                                     {"internal", RPCArg::Type::BOOL, RPCArg::Default{false}, "Whether matching outputs should be treated as not incoming payments (e.g. change)"},
diff --git a/src/wallet/scriptpubkeyman.cpp b/src/wallet/scriptpubkeyman.cpp
index 947efc82715cb..f08852e3207f7 100644
--- a/src/wallet/scriptpubkeyman.cpp
+++ b/src/wallet/scriptpubkeyman.cpp
@@ -1926,7 +1926,7 @@ std::map<CKeyID, CKey> DescriptorScriptPubKeyMan::GetKeys() const
     AssertLockHeld(cs_desc_man);
     if (m_storage.HasEncryptionKeys() && !m_storage.IsLocked(true)) {
         KeyMap keys;
-        for (auto key_pair : m_map_crypted_keys) {
+        for (const auto& key_pair : m_map_crypted_keys) {
             const CPubKey& pubkey = key_pair.second.first;
             const std::vector<unsigned char>& crypted_secret = key_pair.second.second;
             CKey key;
diff --git a/src/wallet/spend.cpp b/src/wallet/spend.cpp
index 3692b7be1b6f9..1de3acd1e16b0 100644
--- a/src/wallet/spend.cpp
+++ b/src/wallet/spend.cpp
@@ -313,7 +313,7 @@ std::map<CTxDestination, std::vector<COutput>> ListCoins(const CWallet& wallet)
 
     std::map<CTxDestination, std::vector<COutput>> result;
 
-    for (const COutput& coin : AvailableCoinsListUnspent(wallet).all()) {
+    for (COutput& coin : AvailableCoinsListUnspent(wallet).all()) {
         CTxDestination address;
         if ((coin.spendable || (wallet.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) && coin.solvable)) &&
             ExtractDestination(FindNonChangeParentOutput(wallet, coin.outpoint).scriptPubKey, address)) {
diff --git a/src/wallet/test/bip39_tests.cpp b/src/wallet/test/bip39_tests.cpp
index e15d30f8fc980..6c6ee703bcb8e 100644
--- a/src/wallet/test/bip39_tests.cpp
+++ b/src/wallet/test/bip39_tests.cpp
@@ -25,7 +25,7 @@ BOOST_AUTO_TEST_CASE(bip39_vectors)
 
     for (unsigned int i = 0; i < tests.size(); i++) {
         // printf("%d\n", i);
-        UniValue test = tests[i];
+        const UniValue& test = tests[i];
         std::string strTest = test.write();
         if (test.size() < 4) // Allow for extra stuff (useful for comments)
         {
diff --git a/src/wallet/test/wallet_tests.cpp b/src/wallet/test/wallet_tests.cpp
index 46f5d3c207739..f219766a87bbb 100644
--- a/src/wallet/test/wallet_tests.cpp
+++ b/src/wallet/test/wallet_tests.cpp
@@ -65,9 +65,6 @@ static std::shared_ptr<CWallet> TestLoadWallet(WalletContext& context)
         AddWallet(context, wallet);
     }
     NotifyWalletLoaded(context, wallet);
-    if (context.chain) {
-        wallet->postInitProcess();
-    }
     return wallet;
 }
 
@@ -784,6 +781,7 @@ BOOST_FIXTURE_TEST_CASE(CreateWallet, TestChain100Setup)
     // being blocked
     wallet = TestLoadWallet(context);
     BOOST_CHECK(rescan_completed);
+    // AddToWallet events for block_tx and mempool_tx
     BOOST_CHECK_EQUAL(addtx_count, 2);
     {
         LOCK(wallet->cs_wallet);
@@ -796,6 +794,8 @@ BOOST_FIXTURE_TEST_CASE(CreateWallet, TestChain100Setup)
     // transactionAddedToMempool events are processed
     promise.set_value();
     SyncWithValidationInterfaceQueue();
+    // AddToWallet events for block_tx and mempool_tx events are counted a
+    // second time as the notification queue is processed
     BOOST_CHECK_EQUAL(addtx_count, 4);
 
     TestUnloadWallet(context, std::move(wallet));
@@ -818,7 +818,7 @@ BOOST_FIXTURE_TEST_CASE(CreateWallet, TestChain100Setup)
             SyncWithValidationInterfaceQueue();
         });
     wallet = TestLoadWallet(context);
-    BOOST_CHECK_EQUAL(addtx_count, 4);
+    BOOST_CHECK_EQUAL(addtx_count, 2);
     {
         LOCK(wallet->cs_wallet);
         BOOST_CHECK_EQUAL(wallet->mapWallet.count(block_tx.GetHash()), 1U);
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index 1caf30747a3b0..6fff7dd2b03c1 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -1685,7 +1685,8 @@ int64_t CWallet::RescanFromTime(int64_t startTime, const WalletRescanReserver& r
 /**
  * Scan the block chain (starting in start_block) for transactions
  * from or to us. If fUpdate is true, found transactions that already
- * exist in the wallet will be updated.
+ * exist in the wallet will be updated. If max_height is not set, the
+ * mempool will be scanned as well.
  *
  * @param[in] start_block Scan starting block. If block is not on the active
  *                        chain, the scan will return SUCCESS immediately.
@@ -1806,6 +1807,10 @@ CWallet::ScanResult CWallet::ScanForWalletTransactions(const uint256& start_bloc
             }
         }
     }
+    if (!max_height) {
+        WalletLogPrintf("Scanning current mempool transactions.\n");
+        WITH_LOCK(cs_wallet, chain().requestMempoolTransactions(*this));
+    }
     ShowProgress(strprintf("%s " + _("Rescanning…").translated, GetDisplayName()), 100); // hide progress dialog in GUI
     if (block_height && fAbortRescan) {
         WalletLogPrintf("Rescan aborted at block %d. Progress=%f\n", block_height, progress_current);
diff --git a/src/wallet/walletdb.cpp b/src/wallet/walletdb.cpp
index e2e4452d64daa..a850b16d236c8 100644
--- a/src/wallet/walletdb.cpp
+++ b/src/wallet/walletdb.cpp
@@ -884,14 +884,14 @@ DBErrors WalletBatch::LoadWallet(CWallet* pwallet)
     }
 
     // Set the descriptor caches
-    for (auto desc_cache_pair : wss.m_descriptor_caches) {
+    for (const auto& desc_cache_pair : wss.m_descriptor_caches) {
         auto spk_man = pwallet->GetScriptPubKeyMan(desc_cache_pair.first);
         assert(spk_man);
         ((DescriptorScriptPubKeyMan*)spk_man)->SetCache(desc_cache_pair.second);
     }
 
     // Set the descriptor keys
-    for (auto desc_key_pair : wss.m_descriptor_keys) {
+    for (const auto& desc_key_pair : wss.m_descriptor_keys) {
         auto spk_man = pwallet->GetScriptPubKeyMan(desc_key_pair.first.first);
         auto it = wss.mnemonics.find(desc_key_pair.first);
         if (it == wss.mnemonics.end()) {
@@ -901,7 +901,7 @@ DBErrors WalletBatch::LoadWallet(CWallet* pwallet)
         }
     }
 
-    for (auto desc_key_pair : wss.m_descriptor_crypt_keys) {
+    for (const auto& desc_key_pair : wss.m_descriptor_crypt_keys) {
         auto spk_man = pwallet->GetScriptPubKeyMan(desc_key_pair.first.first);
         auto it = wss.crypted_mnemonics.find(desc_key_pair.first);
         if (it == wss.crypted_mnemonics.end()) {
diff --git a/test/functional/rpc_wipewallettxes.py b/test/functional/rpc_wipewallettxes.py
index 5a6560bde07b0..0a594f6288d7e 100755
--- a/test/functional/rpc_wipewallettxes.py
+++ b/test/functional/rpc_wipewallettxes.py
@@ -32,9 +32,9 @@ def run_test(self):
         assert_equal(self.nodes[0].getwalletinfo()["txcount"], 104)
         self.nodes[0].wipewallettxes(True)
         assert_equal(self.nodes[0].getwalletinfo()["txcount"], 103)
-        self.nodes[0].rescanblockchain()
-        assert_equal(self.nodes[0].getwalletinfo()["txcount"], 103)
         assert_raises_rpc_error(-5, "Invalid or non-wallet transaction id", self.nodes[0].gettransaction, txid)
+        self.nodes[0].rescanblockchain()
+        assert_equal(self.nodes[0].getwalletinfo()["txcount"], 104)
 
 
 if __name__ == '__main__':
diff --git a/test/functional/wallet_balance.py b/test/functional/wallet_balance.py
index 0142f89158d0f..ba9022bc7f7c4 100755
--- a/test/functional/wallet_balance.py
+++ b/test/functional/wallet_balance.py
@@ -280,6 +280,29 @@ def test_balances(*, fee_node_1=0):
         self.generatetoaddress(self.nodes[1], 1, ADDRESS_WATCHONLY)
         assert_equal(self.nodes[0].getbalance(minconf=0), total_amount + 1)  # The reorg recovered our fee of 1 coin
 
+        if not self.options.descriptors:
+            self.log.info('Check if mempool is taken into account after import*')
+            address = self.nodes[0].getnewaddress()
+            privkey = self.nodes[0].dumpprivkey(address)
+            self.nodes[0].sendtoaddress(address, 0.1)
+            self.nodes[0].unloadwallet('')
+            # check importaddress on fresh wallet
+            self.nodes[0].createwallet('w1', False, True)
+            self.nodes[0].importaddress(address)
+            assert_equal(self.nodes[0].getbalances()['mine']['untrusted_pending'], 0)
+            assert_equal(self.nodes[0].getbalances()['watchonly']['untrusted_pending'], Decimal('0.1'))
+            self.nodes[0].importprivkey(privkey)
+            assert_equal(self.nodes[0].getbalances()['mine']['untrusted_pending'], Decimal('0.1'))
+            self.log.info(f"balance: {self.nodes[0].getbalances()}")
+            # TODO: this code is diversed with bitcoin core, because we don't add `watchonly` in this particular case for 0 balance
+            if 'watchonly' in self.nodes[0].getbalances():
+                assert_equal(self.nodes[0].getbalances()['watchonly']['untrusted_pending'], 0)
+            self.nodes[0].unloadwallet('w1')
+            # check importprivkey on fresh wallet
+            self.nodes[0].createwallet('w2', False, True)
+            self.nodes[0].importprivkey(privkey)
+            assert_equal(self.nodes[0].getbalances()['mine']['untrusted_pending'], Decimal('0.1'))
+
 
 if __name__ == '__main__':
     WalletTest().main()
diff --git a/test/functional/wallet_import_rescan.py b/test/functional/wallet_import_rescan.py
index 12424c4d7c7f9..1a42a8611918a 100755
--- a/test/functional/wallet_import_rescan.py
+++ b/test/functional/wallet_import_rescan.py
@@ -20,7 +20,6 @@
 """
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.governance import EXPECTED_STDERR_NO_GOV_PRUNE
 from test_framework.util import (
     assert_equal,
     set_node_times,
@@ -77,6 +76,7 @@ def check(self, txid=None, amount=None, confirmation_height=None):
         assert_equal(len(txs), self.expected_txs)
 
         addresses = self.node.listreceivedbyaddress(minconf=0, include_watchonly=True, address_filter=self.address['address'])
+
         if self.expected_txs:
             assert_equal(len(addresses[0]["txids"]), self.expected_txs)
 
@@ -88,13 +88,18 @@ def check(self, txid=None, amount=None, confirmation_height=None):
             assert_equal(tx["category"], "receive")
             assert_equal(tx["label"], self.label)
             assert_equal(tx["txid"], txid)
-            assert_equal(tx["confirmations"], 1 + current_height - confirmation_height)
-            assert "trusted" not in tx
+
+            # If no confirmation height is given, the tx is still in the
+            # mempool.
+            confirmations = (1 + current_height - confirmation_height) if confirmation_height else 0
+            assert_equal(tx["confirmations"], confirmations)
+            if confirmations:
+                assert "trusted" not in tx
 
             address, = [ad for ad in addresses if txid in ad["txids"]]
             assert_equal(address["address"], self.address["address"])
             assert_equal(address["amount"], self.expected_balance)
-            assert_equal(address["confirmations"], 1 + current_height - confirmation_height)
+            assert_equal(address["confirmations"], confirmations)
             # Verify the transaction is correctly marked watchonly depending on
             # whether the transaction pays to an imported public key or
             # imported private key. The test setup ensures that transaction
@@ -153,11 +158,12 @@ def setup_network(self):
         self.import_deterministic_coinbase_privkeys()
         self.stop_nodes()
 
-        self.start_nodes()
+        self.start_nodes(extra_args=[["-whitelist=noban@127.0.0.1"]] * self.num_nodes)
         for i in range(1, self.num_nodes):
             self.connect_nodes(i, 0)
 
     def run_test(self):
+
         # Create one transaction on node 0 with a unique amount for
         # each possible type of wallet import RPC.
         for i, variant in enumerate(IMPORT_VARIANTS):
@@ -195,7 +201,7 @@ def run_test(self):
                 variant.check()
 
         # Create new transactions sending to each address.
-        for i, variant in enumerate(IMPORT_VARIANTS):
+        for variant in IMPORT_VARIANTS:
             variant.sent_amount = get_rand_amount()
             variant.sent_txid = self.nodes[0].sendtoaddress(variant.address["address"], variant.sent_amount)
             self.generate(self.nodes[0], 1)  # Generate one block for each send
@@ -210,10 +216,45 @@ def run_test(self):
             variant.expected_balance += variant.sent_amount
             variant.expected_txs += 1
             variant.check(variant.sent_txid, variant.sent_amount, variant.confirmation_height)
-        for i, import_node in enumerate(IMPORT_NODES, 2):
-            if import_node.prune:
-                self.stop_node(i, expected_stderr=EXPECTED_STDERR_NO_GOV_PRUNE)
 
+        self.log.info('Test that the mempool is rescanned as well if the rescan parameter is set to true')
+
+        # The late timestamp and pruned variants are not necessary when testing mempool rescan
+        mempool_variants = [variant for variant in IMPORT_VARIANTS if variant.rescan != Rescan.late_timestamp and not variant.prune]
+        # No further blocks are mined so the timestamp will stay the same
+        timestamp = self.nodes[0].getblockheader(self.nodes[0].getbestblockhash())["time"]
+
+        # Create one transaction on node 0 with a unique amount for
+        # each possible type of wallet import RPC.
+        for i, variant in enumerate(mempool_variants):
+            variant.label = "mempool label {} {}".format(i, variant)
+            variant.address = self.nodes[1].getaddressinfo(self.nodes[1].getnewaddress(
+                label=variant.label,
+            ))
+            variant.key = self.nodes[1].dumpprivkey(variant.address["address"])
+            variant.initial_amount = get_rand_amount()
+            variant.initial_txid = self.nodes[0].sendtoaddress(variant.address["address"], variant.initial_amount)
+            variant.confirmation_height = 0
+            variant.timestamp = timestamp
+
+        assert_equal(len(self.nodes[0].getrawmempool()), len(mempool_variants))
+        self.sync_mempools()
+
+        # For each variation of wallet key import, invoke the import RPC and
+        # check the results from getbalance and listtransactions.
+        for variant in mempool_variants:
+            self.log.info('Run import for mempool variant {}'.format(variant))
+            expect_rescan = variant.rescan == Rescan.yes
+            variant.node = self.nodes[2 + IMPORT_NODES.index(ImportNode(variant.prune, expect_rescan))]
+            variant.do_import(variant.timestamp)
+            if expect_rescan:
+                variant.expected_balance = variant.initial_amount
+                variant.expected_txs = 1
+                variant.check(variant.initial_txid, variant.initial_amount)
+            else:
+                variant.expected_balance = 0
+                variant.expected_txs = 0
+                variant.check()
 
 
 if __name__ == "__main__":
diff --git a/test/functional/wallet_importdescriptors.py b/test/functional/wallet_importdescriptors.py
index 8c30b042ffb8b..9d961c69885bf 100755
--- a/test/functional/wallet_importdescriptors.py
+++ b/test/functional/wallet_importdescriptors.py
@@ -427,7 +427,7 @@ def run_test(self):
         assert_equal(wmulti_priv.getwalletinfo()['keypoolsize'], 1000)
         txid = w0.sendtoaddress(addr, 10)
         self.generate(self.nodes[0], 6)
-        wmulti_priv.sendtoaddress(w0.getnewaddress(), 8) # uses change 1
+        send_txid = wmulti_priv.sendtoaddress(w0.getnewaddress(), 8) # uses change 1
         self.sync_all()
 
         self.nodes[1].createwallet(wallet_name="wmulti_pub", disable_private_keys=True, blank=True, descriptors=True)
@@ -454,7 +454,9 @@ def run_test(self):
         addr = wmulti_pub.getnewaddress() # uses receive 1
         assert_equal(addr, '91cA4fLGaDCr6b9W2c5j1ph9PDpq9WbEhk') # Derived at m/84'/0'/0'/1
         change_addr = wmulti_pub.getrawchangeaddress() # uses receive 2
-        assert_equal(change_addr, '91WxMwg2NHD1PwHChhbAkeCN6nQ8ikdLEx')
+        assert_equal(change_addr, '8y2sLiPQnB81bAeiRvwbjozJXnCCNH2nHb')
+        assert(send_txid in self.nodes[0].getrawmempool(True))
+        assert(send_txid in (x['txid'] for x in wmulti_pub.listunspent(0)))
         assert_equal(wmulti_pub.getwalletinfo()['keypoolsize'], 999)
 
         # generate some utxos for next tests
diff --git a/test/lint/run-lint-format-strings.py b/test/lint/run-lint-format-strings.py
index 985a1c5b6fd9e..4e06a93f44d30 100755
--- a/test/lint/run-lint-format-strings.py
+++ b/test/lint/run-lint-format-strings.py
@@ -28,8 +28,6 @@
     ("src/wallet/wallet.h", "LogPrintf((\"%s \" + fmt).c_str(), GetDisplayName(), parameters...)"),
     ("src/wallet/scriptpubkeyman.h",  "WalletLogPrintf(std::string fmt, Params... parameters)"),
     ("src/wallet/scriptpubkeyman.h", "LogPrintf((\"%s \" + fmt).c_str(), m_storage.GetDisplayName(), parameters...)"),
-    ("src/logging.h", "LogPrintf(const char* fmt, const Args&... args)"),
-    ("src/wallet/scriptpubkeyman.h", "WalletLogPrintf(const std::string& fmt, const Params&... parameters)"),
 ]
 
 def parse_function_calls(function_name, source_code):