diff --git a/src/Makefile.am b/src/Makefile.am
index a26a5d980bdd..5934cd2fcfd6 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -296,6 +296,7 @@ BITCOIN_CORE_H = \
   util/macros.h \
   util/memory.h \
   util/moneystr.h \
+  util/ranges.h \
   util/serfloat.h \
   util/string.h \
   util/time.h \
diff --git a/src/bls/bls.h b/src/bls/bls.h
index 39b82c1e2f6d..c313be377e77 100644
--- a/src/bls/bls.h
+++ b/src/bls/bls.h
@@ -9,6 +9,7 @@
 #include <serialize.h>
 #include <uint256.h>
 #include <util/strencodings.h>
+#include <util/ranges.h>
 
 // bls-dash uses relic, which may define DEBUG and ERROR, which leads to many warnings in some build setups
 #undef ERROR
@@ -108,7 +109,7 @@ class CBLSWrapper
             return;
         }
 
-        if (std::all_of(vecBytes.begin(), vecBytes.end(), [](uint8_t c) { return c == 0; })) {
+        if (ranges::all_of(vecBytes, [](uint8_t c) { return c == 0; })) {
             Reset();
         } else {
             try {
diff --git a/src/bls/bls_worker.cpp b/src/bls/bls_worker.cpp
index 0bf5a6a34d93..8c6947c5cee8 100644
--- a/src/bls/bls_worker.cpp
+++ b/src/bls/bls_worker.cpp
@@ -6,6 +6,7 @@
 #include <hash.h>
 #include <serialize.h>
 
+#include <util/ranges.h>
 #include <util/system.h>
 
 #include <memory>
@@ -111,7 +112,7 @@ bool CBLSWorker::GenerateContributions(int quorumThreshold, const BLSIdVector& i
         };
         futures.emplace_back(workerPool.push(f));
     }
-    return std::all_of(futures.begin(), futures.end(), [](auto& f){
+    return ranges::all_of(futures, [](auto& f){
         return f.get();
     });
 }
@@ -802,13 +803,9 @@ void CBLSWorker::AsyncVerifySig(const CBLSSignature& sig, const CBLSPublicKey& p
 
     std::unique_lock<std::mutex> l(sigVerifyMutex);
 
-    bool foundDuplicate = false;
-    for (const auto& s : sigVerifyQueue) {
-        if (s.msgHash == msgHash) {
-            foundDuplicate = true;
-            break;
-        }
-    }
+    bool foundDuplicate = ranges::any_of(sigVerifyQueue, [&msgHash](const auto& job){
+        return job.msgHash == msgHash;
+    });
 
     if (foundDuplicate) {
         // batched/aggregated verification does not allow duplicate hashes, so we push what we currently have and start
diff --git a/src/coinjoin/client.cpp b/src/coinjoin/client.cpp
index 53fcda8b5264..5540eea47b6f 100644
--- a/src/coinjoin/client.cpp
+++ b/src/coinjoin/client.cpp
@@ -17,6 +17,7 @@
 #include <shutdown.h>
 #include <txmempool.h>
 #include <util/moneystr.h>
+#include <util/ranges.h>
 #include <util/system.h>
 #include <validation.h>
 #include <version.h>
@@ -87,13 +88,10 @@ void CCoinJoinClientQueueManager::ProcessMessage(CNode* pfrom, const std::string
         }
 
         // if the queue is ready, submit if we can
-        if (dsq.fReady) {
-            for (const auto& pair : coinJoinClientManagers) {
-                if (pair.second->TrySubmitDenominate(dmn->pdmnState->addr, connman)) {
-                    LogPrint(BCLog::COINJOIN, "DSQUEUE -- CoinJoin queue (%s) is ready on masternode %s\n", dsq.ToString(), dmn->pdmnState->addr.ToString());
-                    return;
-                }
-            }
+        if (dsq.fReady && ranges::any_of(coinJoinClientManagers,
+                                         [&dmn, &connman](const auto& pair){ return pair.second->TrySubmitDenominate(dmn->pdmnState->addr, connman); })) {
+            LogPrint(BCLog::COINJOIN, "DSQUEUE -- CoinJoin queue (%s) is ready on masternode %s\n", dsq.ToString(), dmn->pdmnState->addr.ToString());
+            return;
         } else {
             int64_t nLastDsq = mmetaman.GetMetaInfo(dmn->proTxHash)->GetLastDsq();
             int64_t nDsqThreshold = mmetaman.GetDsqThreshold(dmn->proTxHash, mnList.GetValidMNsCount());
@@ -108,11 +106,8 @@ void CCoinJoinClientQueueManager::ProcessMessage(CNode* pfrom, const std::string
 
             LogPrint(BCLog::COINJOIN, "DSQUEUE -- new CoinJoin queue (%s) from masternode %s\n", dsq.ToString(), dmn->pdmnState->addr.ToString());
 
-            for (const auto& pair : coinJoinClientManagers) {
-                if (pair.second->MarkAlreadyJoinedQueueAsTried(dsq)) {
-                    break;
-                }
-            }
+            ranges::any_of(coinJoinClientManagers,
+                           [&dsq](const auto& pair){ return pair.second->MarkAlreadyJoinedQueueAsTried(dsq); });
 
             TRY_LOCK(cs_vecqueue, lockRecv);
             if (!lockRecv) return;
@@ -597,13 +592,9 @@ bool CCoinJoinClientSession::SignFinalTransaction(const CTransaction& finalTrans
     for (const auto &entry: vecEntries) {
         // Check that the final transaction has all our outputs
         for (const auto &txout: entry.vecTxOut) {
-            bool fFound = false;
-            for (const auto &txoutFinal: finalMutableTransaction.vout) {
-                if (txoutFinal == txout) {
-                    fFound = true;
-                    break;
-                }
-            }
+            bool fFound = ranges::any_of(finalMutableTransaction.vout, [&txout](const auto& txoutFinal){
+                return txoutFinal == txout;
+            });
             if (!fFound) {
                 // Something went wrong and we'll refuse to sign. It's possible we'll be charged collateral. But that's
                 // better than signing if the transaction doesn't look like what we wanted.
diff --git a/src/coinjoin/coinjoin.cpp b/src/coinjoin/coinjoin.cpp
index 4660fe1884dc..4c4a09d390eb 100644
--- a/src/coinjoin/coinjoin.cpp
+++ b/src/coinjoin/coinjoin.cpp
@@ -136,7 +136,7 @@ bool CCoinJoinBroadcastTx::IsValidStructure() const
     if (tx->vin.size() > CCoinJoin::GetMaxPoolParticipants() * COINJOIN_ENTRY_MAX_SIZE) {
         return false;
     }
-    return std::all_of(tx->vout.cbegin(), tx->vout.cend(), [] (const auto& txOut){
+    return ranges::all_of(tx->vout, [] (const auto& txOut){
         return CCoinJoin::IsDenominatedAmount(txOut.nValue) && txOut.scriptPubKey.IsPayToPublicKeyHash();
     });
 }
@@ -389,11 +389,10 @@ bool CCoinJoin::IsCollateralAmount(CAmount nInputAmount)
 
 int CCoinJoin::CalculateAmountPriority(CAmount nInputAmount)
 {
-    for (const auto& d : GetStandardDenominations()) {
-        // large denoms have lower value
-        if (nInputAmount == d) {
-            return (float)COIN / d * 10000;
-        }
+    if (auto optDenom = ranges::find_if_opt(GetStandardDenominations(), [&nInputAmount](const auto& denom) {
+        return nInputAmount == denom;
+    })) {
+        return (float)COIN / *optDenom * 10000;
     }
     if (nInputAmount < COIN) {
         return 20000;
diff --git a/src/coinjoin/server.cpp b/src/coinjoin/server.cpp
index 40497a2c1381..550eb2d7bf55 100644
--- a/src/coinjoin/server.cpp
+++ b/src/coinjoin/server.cpp
@@ -15,6 +15,7 @@
 #include <script/interpreter.h>
 #include <shutdown.h>
 #include <txmempool.h>
+#include <util/ranges.h>
 #include <util/system.h>
 #include <util/moneystr.h>
 #include <validation.h>
@@ -81,13 +82,14 @@ void CCoinJoinServer::ProcessDSACCEPT(CNode* pfrom, const std::string& strComman
             TRY_LOCK(cs_vecqueue, lockRecv);
             if (!lockRecv) return;
 
-            for (const auto& q : vecCoinJoinQueue) {
-                if (WITH_LOCK(activeMasternodeInfoCs, return q.masternodeOutpoint == activeMasternodeInfo.outpoint)) {
-                    // refuse to create another queue this often
-                    LogPrint(BCLog::COINJOIN, "DSACCEPT -- last dsq is still in queue, refuse to mix\n");
-                    PushStatus(pfrom, STATUS_REJECTED, ERR_RECENT, connman);
-                    return;
-                }
+            auto mnOutpoint = WITH_LOCK(activeMasternodeInfoCs, return activeMasternodeInfo.outpoint);
+
+            if (ranges::any_of(vecCoinJoinQueue,
+                               [&mnOutpoint](const auto& q){return q.masternodeOutpoint == mnOutpoint;})) {
+                // refuse to create another queue this often
+                LogPrint(BCLog::COINJOIN, "DSACCEPT -- last dsq is still in queue, refuse to mix\n");
+                PushStatus(pfrom, STATUS_REJECTED, ERR_RECENT, connman);
+                return;
             }
         }
 
@@ -400,13 +402,9 @@ void CCoinJoinServer::ChargeFees(CConnman& connman) const
     if (nState == POOL_STATE_ACCEPTING_ENTRIES) {
         LOCK(cs_coinjoin);
         for (const auto& txCollateral : vecSessionCollaterals) {
-            bool fFound = false;
-            for (const auto& entry : vecEntries) {
-                if (*entry.txCollateral == *txCollateral) {
-                    fFound = true;
-                    break;
-                }
-            }
+            bool fFound = ranges::any_of(vecEntries, [&txCollateral](const auto& entry){
+                return *entry.txCollateral == *txCollateral;
+            });
 
             // This queue entry didn't send us the promised transaction
             if (!fFound) {
@@ -608,15 +606,16 @@ bool CCoinJoinServer::AddEntry(CConnman& connman, const CCoinJoinEntry& entry, P
         LogPrint(BCLog::COINJOIN, "CCoinJoinServer::%s -- txin=%s\n", __func__, txin.ToString());
         LOCK(cs_coinjoin);
         for (const auto& inner_entry : vecEntries) {
-            for (const auto& txdsin : inner_entry.vecTxDSIn) {
-                if (txdsin.prevout == txin.prevout) {
-                    LogPrint(BCLog::COINJOIN, "CCoinJoinServer::%s -- ERROR: already have this txin in entries\n", __func__);
-                    nMessageIDRet = ERR_ALREADY_HAVE;
-                    // Two peers sent the same input? Can't really say who is the malicious one here,
-                    // could be that someone is picking someone else's inputs randomly trying to force
-                    // collateral consumption. Do not punish.
-                    return false;
-                }
+            if (ranges::any_of(inner_entry.vecTxDSIn,
+                            [&txin](const auto& txdsin){
+                                    return txdsin.prevout == txin.prevout;
+                            })) {
+                LogPrint(BCLog::COINJOIN, "CCoinJoinServer::%s -- ERROR: already have this txin in entries\n", __func__);
+                nMessageIDRet = ERR_ALREADY_HAVE;
+                // Two peers sent the same input? Can't really say who is the malicious one here,
+                // could be that someone is picking someone else's inputs randomly trying to force
+                // collateral consumption. Do not punish.
+                return false;
             }
         }
         vin.emplace_back(txin);
@@ -647,11 +646,10 @@ bool CCoinJoinServer::AddScriptSig(const CTxIn& txinNew)
 
     LOCK(cs_coinjoin);
     for (const auto& entry : vecEntries) {
-        for (const auto& txdsin : entry.vecTxDSIn) {
-            if (txdsin.scriptSig == txinNew.scriptSig) {
-                LogPrint(BCLog::COINJOIN, "CCoinJoinServer::AddScriptSig -- already exists\n");
-                return false;
-            }
+        if (ranges::any_of(entry.vecTxDSIn,
+                        [&txinNew](const auto& txdsin){ return txdsin.scriptSig == txinNew.scriptSig; })){
+            LogPrint(BCLog::COINJOIN, "CCoinJoinServer::AddScriptSig -- already exists\n");
+            return false;
         }
     }
 
@@ -683,13 +681,10 @@ bool CCoinJoinServer::AddScriptSig(const CTxIn& txinNew)
 bool CCoinJoinServer::IsSignaturesComplete() const
 {
     LOCK(cs_coinjoin);
-    for (const auto& entry : vecEntries) {
-        for (const auto& txdsin : entry.vecTxDSIn) {
-            if (!txdsin.fHasSig) return false;
-        }
-    }
 
-    return true;
+    return ranges::all_of(vecEntries, [](const auto& entry){
+        return ranges::all_of(entry.vecTxDSIn, [](const auto& txdsin){return txdsin.fHasSig;});
+    });
 }
 
 bool CCoinJoinServer::IsAcceptableDSA(const CCoinJoinAccept& dsa, PoolMessage& nMessageIDRet) const
diff --git a/src/coinjoin/util.cpp b/src/coinjoin/util.cpp
index 7ab33f5768f9..c1e1dd28ad98 100644
--- a/src/coinjoin/util.cpp
+++ b/src/coinjoin/util.cpp
@@ -12,6 +12,8 @@
 #include <wallet/fees.h>
 #include <wallet/wallet.h>
 
+#include <numeric>
+
 inline unsigned int GetSizeOfCompactSizeDiff(uint64_t nSizePrev, uint64_t nSizeNew)
 {
     assert(nSizePrev <= nSizeNew);
@@ -221,12 +223,10 @@ CAmount CTransactionBuilder::GetAmountLeft(const CAmount nAmountInitial, const C
 
 CAmount CTransactionBuilder::GetAmountUsed() const
 {
-    CAmount nAmountUsed{0};
     LOCK(cs_outputs);
-    for (const auto& out : vecOutputs) {
-        nAmountUsed += out->GetAmount();
-    }
-    return nAmountUsed;
+    return std::accumulate(vecOutputs.begin(), vecOutputs.end(), CAmount{0}, [](const CAmount& a, const auto& b){
+        return a + b->GetAmount();
+    });
 }
 
 CAmount CTransactionBuilder::GetFee(unsigned int nBytes) const
diff --git a/src/evo/deterministicmns.cpp b/src/evo/deterministicmns.cpp
index f1f649507e6b..ed55c1881377 100644
--- a/src/evo/deterministicmns.cpp
+++ b/src/evo/deterministicmns.cpp
@@ -151,12 +151,12 @@ CDeterministicMNCPtr CDeterministicMNList::GetValidMN(const uint256& proTxHash)
 
 CDeterministicMNCPtr CDeterministicMNList::GetMNByOperatorKey(const CBLSPublicKey& pubKey) const
 {
-    for (const auto& p : mnMap) {
-        if (p.second->pdmnState->pubKeyOperator.Get() == pubKey) {
-            return p.second;
-        }
+    const auto it = ranges::find_if(mnMap,
+                              [&pubKey](const auto& p){return p.second->pdmnState->pubKeyOperator.Get() == pubKey;});
+    if (it == mnMap.end()) {
+        return nullptr;
     }
-    return nullptr;
+    return it->second;
 }
 
 CDeterministicMNCPtr CDeterministicMNList::GetMNByCollateral(const COutPoint& collateralOutpoint) const
@@ -1014,11 +1014,12 @@ CDeterministicMNList CDeterministicMNManager::GetListForBlock(const CBlockIndex*
             mnListsCache.emplace(snapshot.GetBlockHash(), snapshot);
         } else {
             // keep snapshots for yet alive quorums
-            for (auto& p_llmq : Params().GetConsensus().llmqs) {
-                if ((snapshot.GetHeight() % p_llmq.second.dkgInterval == 0) && (snapshot.GetHeight() + p_llmq.second.dkgInterval * (p_llmq.second.keepOldConnections + 1) >= tipIndex->nHeight)) {
-                    mnListsCache.emplace(snapshot.GetBlockHash(), snapshot);
-                    break;
-                }
+            if (ranges::any_of(Params().GetConsensus().llmqs, [&snapshot, this](const auto& p_llmq){
+                const auto& [_, params] = p_llmq; LOCK(cs);
+                return (snapshot.GetHeight() % params.dkgInterval == 0) &&
+                (snapshot.GetHeight() + params.dkgInterval * (params.keepOldConnections + 1) >= tipIndex->nHeight);
+            })) {
+                mnListsCache.emplace(snapshot.GetBlockHash(), snapshot);
             }
         }
     }
@@ -1084,13 +1085,11 @@ void CDeterministicMNManager::CleanupCache(int nHeight)
             toDeleteLists.emplace_back(p.first);
             continue;
         }
-        bool fQuorumCache{false};
-        for (auto& p_llmq : Params().GetConsensus().llmqs) {
-            if ((p.second.GetHeight() % p_llmq.second.dkgInterval == 0) && (p.second.GetHeight() + p_llmq.second.dkgInterval * (p_llmq.second.keepOldConnections + 1) >= nHeight)) {
-                fQuorumCache = true;
-                break;
-            }
-        }
+        bool fQuorumCache = ranges::any_of(Params().GetConsensus().llmqs, [&nHeight, &p](const auto& p_llmq){
+            const auto& [_, params] = p_llmq;
+            return (p.second.GetHeight() % params.dkgInterval == 0) &&
+                   (p.second.GetHeight() + params.dkgInterval * (params.keepOldConnections + 1) >= nHeight);
+        });
         if (fQuorumCache) {
             // at least one quorum could be using it, keep it
             continue;
@@ -1098,13 +1097,9 @@ void CDeterministicMNManager::CleanupCache(int nHeight)
         // no alive quorums using it, see if it was a cache for the tip or for a now outdated quorum
         if (tipIndex && tipIndex->pprev && (p.first == tipIndex->pprev->GetBlockHash())) {
             toDeleteLists.emplace_back(p.first);
-        } else {
-            for (auto& p_llmq : Params().GetConsensus().llmqs) {
-                if (p.second.GetHeight() % p_llmq.second.dkgInterval == 0) {
-                    toDeleteLists.emplace_back(p.first);
-                    break;
-                }
-            }
+        } else if (ranges::any_of(Params().GetConsensus().llmqs,
+                                  [&p](const auto& p_llmq){ return p.second.GetHeight() % p_llmq.second.dkgInterval == 0; })) {
+            toDeleteLists.emplace_back(p.first);
         }
     }
     for (const auto& h : toDeleteLists) {
diff --git a/src/llmq/dkgsession.cpp b/src/llmq/dkgsession.cpp
index 4b64fee7d7c1..c5c55082e58e 100644
--- a/src/llmq/dkgsession.cpp
+++ b/src/llmq/dkgsession.cpp
@@ -301,12 +301,7 @@ void CDKGSession::ReceiveMessage(const CDKGContribution& qc, bool& retBan)
 
     receivedVvecs[member->idx] = qc.vvec;
 
-    int receivedCount = 0;
-    for (const auto& m : members) {
-        if (!m->contributions.empty()) {
-            receivedCount++;
-        }
-    }
+    int receivedCount = ranges::count_if(members, [](const auto& m){return !m->contributions.empty();});
 
     logger.Batch("received and relayed contribution. received=%d/%d, time=%d", receivedCount, members.size(), t1.count());
 
@@ -1174,12 +1169,7 @@ void CDKGSession::ReceiveMessage(const CDKGPrematureCommitment& qc, bool& retBan
         return true;
     });
 
-    int receivedCount = 0;
-    for (const auto& m : members) {
-        if (!m->prematureCommitments.empty()) {
-            receivedCount++;
-        }
-    }
+    int receivedCount = ranges::count_if(members, [](const auto& m){ return !m->prematureCommitments.empty(); });
 
     t1.stop();
 
diff --git a/src/llmq/dkgsessionhandler.h b/src/llmq/dkgsessionhandler.h
index 105cf61c2623..8094544e9a4f 100644
--- a/src/llmq/dkgsessionhandler.h
+++ b/src/llmq/dkgsessionhandler.h
@@ -87,7 +87,7 @@ class CDKGPendingMessages
             ret.emplace_back(std::make_pair(bm.first, std::move(msg)));
         }
 
-        return std::move(ret);
+        return ret;
     }
 };
 
diff --git a/src/llmq/instantsend.cpp b/src/llmq/instantsend.cpp
index faf205ef95e2..992aa1ab401e 100644
--- a/src/llmq/instantsend.cpp
+++ b/src/llmq/instantsend.cpp
@@ -14,6 +14,7 @@
 #include <consensus/validation.h>
 #include <index/txindex.h>
 #include <txmempool.h>
+#include <util/ranges.h>
 #include <masternode/sync.h>
 #include <net_processing.h>
 #include <spork.h>
@@ -591,13 +592,8 @@ bool CInstantSendManager::CheckCanLock(const CTransaction& tx, bool printDebug,
         return false;
     }
 
-    for (const auto& in : tx.vin) {
-        if (!CheckCanLock(in.prevout, printDebug, tx.GetHash(), params)) {
-            return false;
-        }
-    }
-
-    return true;
+    return ranges::all_of(tx.vin,
+                          [&](const auto& in) { return CheckCanLock(in.prevout, printDebug, tx.GetHash(), params); });
 }
 
 bool CInstantSendManager::CheckCanLock(const COutPoint& outpoint, bool printDebug, const uint256& txHash, const Consensus::Params& params) const
diff --git a/src/llmq/quorums.cpp b/src/llmq/quorums.cpp
index 93251829b069..d3385ceeaa40 100644
--- a/src/llmq/quorums.cpp
+++ b/src/llmq/quorums.cpp
@@ -83,12 +83,9 @@ bool CQuorum::SetSecretKeyShare(const CBLSSecretKey& secretKeyShare)
 
 bool CQuorum::IsMember(const uint256& proTxHash) const
 {
-    for (auto& dmn : members) {
-        if (dmn->proTxHash == proTxHash) {
-            return true;
-        }
-    }
-    return false;
+    return ranges::any_of(members, [&proTxHash](const auto& dmn){
+        return dmn->proTxHash == proTxHash;
+    });
 }
 
 bool CQuorum::IsValidMember(const uint256& proTxHash) const
@@ -208,15 +205,10 @@ void CQuorumManager::TriggerQuorumDataRecoveryThreads(const CBlockIndex* pIndex)
         const auto vecQuorums = ScanQuorums(llmq.first, pIndex, llmq.second.signingActiveQuorumCount + 1);
 
         // First check if we are member of any quorum of this type
-        bool fWeAreQuorumTypeMember{false};
-
         auto proTxHash = WITH_LOCK(activeMasternodeInfoCs, return activeMasternodeInfo.proTxHash);
-        for (const auto& pQuorum : vecQuorums) {
-            if (pQuorum->IsValidMember(proTxHash)) {
-                fWeAreQuorumTypeMember = true;
-                break;
-            }
-        }
+        bool fWeAreQuorumTypeMember = ranges::any_of(vecQuorums, [&proTxHash](const auto& pQuorum) {
+            return pQuorum->IsValidMember(proTxHash);
+        });
 
         for (const auto& pQuorum : vecQuorums) {
             // If there is already a thread running for this specific quorum skip it
diff --git a/src/llmq/signing_shares.cpp b/src/llmq/signing_shares.cpp
index 97ab5f747146..16ceb4ac64f4 100644
--- a/src/llmq/signing_shares.cpp
+++ b/src/llmq/signing_shares.cpp
@@ -258,11 +258,10 @@ void CSigSharesManager::ProcessMessage(const CNode* pfrom, const std::string& st
             BanNode(pfrom->GetId());
             return;
         }
-        for (const auto& ann : msgs) {
-            if (!ProcessMessageSigSesAnn(pfrom, ann)) {
-                BanNode(pfrom->GetId());
-                return;
-            }
+        if (!ranges::all_of(msgs,
+                            [this, &pfrom](const auto& ann){ return ProcessMessageSigSesAnn(pfrom, ann); })) {
+            BanNode(pfrom->GetId());
+            return;
         }
     } else if (strCommand == NetMsgType::QSIGSHARESINV) {
         std::vector<CSigSharesInv> msgs;
@@ -272,11 +271,10 @@ void CSigSharesManager::ProcessMessage(const CNode* pfrom, const std::string& st
             BanNode(pfrom->GetId());
             return;
         }
-        for (const auto& inv : msgs) {
-            if (!ProcessMessageSigSharesInv(pfrom, inv)) {
-                BanNode(pfrom->GetId());
-                return;
-            }
+        if (!ranges::all_of(msgs,
+                            [this, &pfrom](const auto& inv){ return ProcessMessageSigSharesInv(pfrom, inv); })) {
+            BanNode(pfrom->GetId());
+            return;
         }
     } else if (strCommand == NetMsgType::QGETSIGSHARES) {
         std::vector<CSigSharesInv> msgs;
@@ -286,11 +284,10 @@ void CSigSharesManager::ProcessMessage(const CNode* pfrom, const std::string& st
             BanNode(pfrom->GetId());
             return;
         }
-        for (const auto& inv : msgs) {
-            if (!ProcessMessageGetSigShares(pfrom, inv)) {
-                BanNode(pfrom->GetId());
-                return;
-            }
+        if (!ranges::all_of(msgs,
+                            [this, &pfrom](const auto& inv){ return ProcessMessageGetSigShares(pfrom, inv); })) {
+            BanNode(pfrom->GetId());
+            return;
         }
     } else if (strCommand == NetMsgType::QBSIGSHARES) {
         std::vector<CBatchedSigShares> msgs;
@@ -304,11 +301,10 @@ void CSigSharesManager::ProcessMessage(const CNode* pfrom, const std::string& st
             BanNode(pfrom->GetId());
             return;
         }
-        for (const auto& bs : msgs) {
-            if (!ProcessMessageBatchedSigShares(pfrom, bs)) {
-                BanNode(pfrom->GetId());
-                return;
-            }
+        if (!ranges::all_of(msgs,
+                            [this, &pfrom](const auto& bs){ return ProcessMessageBatchedSigShares(pfrom, bs); })) {
+            BanNode(pfrom->GetId());
+            return;
         }
     }
 }
diff --git a/src/llmq/utils.cpp b/src/llmq/utils.cpp
index b78857cd99df..c108a278f4df 100644
--- a/src/llmq/utils.cpp
+++ b/src/llmq/utils.cpp
@@ -16,6 +16,7 @@
 #include <random.h>
 #include <spork.h>
 #include <timedata.h>
+#include <util/ranges.h>
 #include <validation.h>
 #include <versionbits.h>
 
@@ -291,12 +292,7 @@ bool CLLMQUtils::IsQuorumActive(Consensus::LLMQType llmqType, const uint256& quo
     // we allow one more active quorum as specified in consensus, as otherwise there is a small window where things could
     // fail while we are on the brink of a new quorum
     auto quorums = quorumManager->ScanQuorums(llmqType, GetLLMQParams(llmqType).signingActiveQuorumCount + 1);
-    for (const auto& q : quorums) {
-        if (q->qc->quorumHash == quorumHash) {
-            return true;
-        }
-    }
-    return false;
+    return ranges::any_of(quorums, [&quorumHash](const auto& q){ return q->qc->quorumHash == quorumHash; });
 }
 
 bool CLLMQUtils::IsQuorumTypeEnabled(Consensus::LLMQType llmqType, const CBlockIndex* pindex)
@@ -374,13 +370,11 @@ std::map<Consensus::LLMQType, QvvecSyncMode> CLLMQUtils::GetEnabledQuorumVvecSyn
         if (!fLLMQTypePresent || !fModePresent || fTooManyEntries) {
             throw std::invalid_argument(strprintf("Invalid format in -llmq-qvvec-sync: %s", strEntry));
         }
-        for (const auto& p : Params().GetConsensus().llmqs) {
-            if (p.second.name == strLLMQType) {
-                llmqType = p.first;
-                break;
-            }
-        }
-        if (llmqType == Consensus::LLMQType::LLMQ_NONE) {
+
+        if (auto optLLMQParams = ranges::find_if_opt(Params().GetConsensus().llmqs,
+                                                     [&strLLMQType](const auto& p){return p.second.name == strLLMQType;})) {
+            llmqType = optLLMQParams->first;
+        } else {
             throw std::invalid_argument(strprintf("Invalid llmqType in -llmq-qvvec-sync: %s", strEntry));
         }
         if (mapQuorumVvecSyncEntries.count(llmqType) > 0) {
diff --git a/src/masternode/payments.cpp b/src/masternode/payments.cpp
index 4a6609c816bc..469226054aa4 100644
--- a/src/masternode/payments.cpp
+++ b/src/masternode/payments.cpp
@@ -16,6 +16,7 @@
 #include <primitives/block.h>
 #include <script/standard.h>
 #include <tinyformat.h>
+#include <util/ranges.h>
 #include <util/system.h>
 #include <validation.h>
 
@@ -324,13 +325,7 @@ bool CMasternodePayments::IsTransactionValid(const CTransaction& txNew, int nBlo
     }
 
     for (const auto& txout : voutMasternodePayments) {
-        bool found = false;
-        for (const auto& txout2 : txNew.vout) {
-            if (txout == txout2) {
-                found = true;
-                break;
-            }
-        }
+        bool found = ranges::any_of(txNew.vout, [&txout](const auto& txout2) {return txout == txout2;});
         if (!found) {
             CTxDestination dest;
             if (!ExtractDestination(txout.scriptPubKey, dest))
diff --git a/src/masternode/utils.cpp b/src/masternode/utils.cpp
index cf0abaa9fae9..e70f2c481399 100644
--- a/src/masternode/utils.cpp
+++ b/src/masternode/utils.cpp
@@ -12,6 +12,7 @@
 #include <net.h>
 #include <shutdown.h>
 #include <validation.h>
+#include <util/ranges.h>
 
 
 void CMasternodeUtils::ProcessMasternodeConnections(CConnman& connman)
@@ -45,13 +46,7 @@ void CMasternodeUtils::ProcessMasternodeConnections(CConnman& connman)
         if (pnode->m_masternode_probe_connection && GetSystemTimeInSeconds() - pnode->nTimeConnected < 5) return;
 
 #ifdef ENABLE_WALLET
-        bool fFound = false;
-        for (const auto& dmn : vecDmns) {
-            if (pnode->addr == dmn->pdmnState->addr) {
-                fFound = true;
-                break;
-            }
-        }
+        bool fFound = ranges::any_of(vecDmns, [&pnode](const auto& dmn){ return pnode->addr == dmn->pdmnState->addr; });
         if (fFound) return; // do NOT disconnect mixing masternodes
 #endif // ENABLE_WALLET
         if (fLogIPs) {
diff --git a/src/spork.cpp b/src/spork.cpp
index 4f9f7d00d8dd..a80cc1311214 100644
--- a/src/spork.cpp
+++ b/src/spork.cpp
@@ -16,6 +16,7 @@
 #include <protocol.h>
 #include <script/standard.h>
 #include <timedata.h>
+#include <util/ranges.h>
 #include <util/validation.h> // for strMessageMagic
 
 #include <string>
@@ -237,22 +238,21 @@ int64_t CSporkManager::GetSporkValue(SporkId nSporkID) const
         return nSporkValue;
     }
 
-    for (const auto& sporkDef : sporkDefs) {
-        if (sporkDef.sporkId == nSporkID) {
-            return sporkDef.defaultValue;
-        }
-    }
 
-    LogPrint(BCLog::SPORK, "CSporkManager::GetSporkValue -- Unknown Spork ID %d\n", nSporkID);
-    return -1;
+    if (auto optSpork = ranges::find_if_opt(sporkDefs,
+                                            [&nSporkID](const auto& sporkDef){return sporkDef.sporkId == nSporkID;})) {
+        return optSpork->defaultValue;
+    } else {
+        LogPrint(BCLog::SPORK, "CSporkManager::GetSporkValue -- Unknown Spork ID %d\n", nSporkID);
+        return -1;
+    }
 }
 
 SporkId CSporkManager::GetSporkIDByName(std::string_view strName)
 {
-    for (const auto& sporkDef : sporkDefs) {
-        if (sporkDef.name == strName) {
-            return sporkDef.sporkId;
-        }
+    if (auto optSpork = ranges::find_if_opt(sporkDefs,
+                                            [&strName](const auto& sporkDef){return sporkDef.name == strName;})) {
+        return optSpork->sporkId;
     }
 
     LogPrint(BCLog::SPORK, "CSporkManager::GetSporkIDByName -- Unknown Spork name '%s'\n", strName);
diff --git a/src/util/ranges.h b/src/util/ranges.h
new file mode 100644
index 000000000000..6c000e3248f2
--- /dev/null
+++ b/src/util/ranges.h
@@ -0,0 +1,44 @@
+// Copyright (c) 2021 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_UTIL_RANGES_H
+#define BITCOIN_UTIL_RANGES_H
+
+#include <algorithm>
+#include <optional>
+
+//#if __cplusplus > 201703L // C++20 compiler
+//namespace ranges = std::ranges;
+//#else
+
+#define MK_RANGE(FUN) \
+template <typename X, typename Z>               \
+inline auto FUN(const X& ds, const Z& fn) {     \
+    return std::FUN(cbegin(ds), cend(ds), fn);  \
+}                                               \
+template <typename X, typename Z>               \
+inline auto FUN(X& ds, const Z& fn) {           \
+    return std::FUN(begin(ds), end(ds), fn);    \
+}
+
+
+namespace ranges {
+    MK_RANGE(all_of)
+    MK_RANGE(any_of)
+    MK_RANGE(count_if)
+    MK_RANGE(find_if)
+
+    template <typename X, typename Z>
+    inline auto find_if_opt(const X& ds, const Z& fn) {
+        const auto it = ranges::find_if(ds, fn);
+        if (it != end(ds)) {
+            return std::make_optional(*it);
+        }
+        return std::optional<std::decay_t<decltype(*it)>>{};
+    }
+
+}
+
+//#endif // C++20 compiler
+#endif // BITCOIN_UTIL_RANGES_H