diff --git a/src/Makefile.am b/src/Makefile.am
index 1926f8ae0b842..1ec24d4700546 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -301,6 +301,7 @@ BITCOIN_CORE_H = \
   util/check.h \
   util/error.h \
   util/fees.h \
+  util/irange.h \
   util/spanparsing.h \
   util/system.h \
   util/asmap.h \
diff --git a/src/bench/bls_dkg.cpp b/src/bench/bls_dkg.cpp
index 256deb17801b6..711de5d083ed1 100644
--- a/src/bench/bls_dkg.cpp
+++ b/src/bench/bls_dkg.cpp
@@ -3,8 +3,9 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <bench/bench.h>
-#include <random.h>
 #include <bls/bls_worker.h>
+#include <random.h>
+#include <util/irange.h>
 
 struct Member {
     CBLSId id;
@@ -27,8 +28,8 @@ class DKG
     void ReceiveVvecs()
     {
         receivedVvecs.clear();
-        for (size_t i = 0; i < members.size(); i++) {
-            receivedVvecs.emplace_back(members[i].vvec);
+        for (const auto& member : members) {
+            receivedVvecs.emplace_back(member.vvec);
         }
         quorumVvec = blsWorker.BuildQuorumVerificationVector(receivedVvecs);
     }
@@ -36,15 +37,15 @@ class DKG
     void ReceiveShares(size_t whoAmI)
     {
         receivedSkShares.clear();
-        for (size_t i = 0; i < members.size(); i++) {
-            receivedSkShares.emplace_back(members[i].skShares[whoAmI]);
+        for (const auto& member : members) {
+            receivedSkShares.emplace_back(member.skShares[whoAmI]);
         }
     }
 
     void VerifyContributionShares(size_t whoAmI, const std::set<size_t>& invalidIndexes, bool aggregated)
     {
         auto result = blsWorker.VerifyContributionShares(members[whoAmI].id, receivedVvecs, receivedSkShares, aggregated);
-        for (size_t i = 0; i < receivedVvecs.size(); i++) {
+        for (const size_t i : irange::range(receivedVvecs.size())) {
             if (invalidIndexes.count(i)) {
                 assert(!result[i]);
             } else {
@@ -59,7 +60,7 @@ class DKG
         members.reserve(quorumSize);
         ids.reserve(quorumSize);
 
-        for (int i = 0; i < quorumSize; i++) {
+        for (const int i : irange::range(quorumSize)) {
             uint256 id;
             WriteLE64(id.begin(), i + 1);
             members.push_back({CBLSId(id), {}, {}});
@@ -67,8 +68,8 @@ class DKG
         }
 
         blsWorker.Start();
-        for (int i = 0; i < quorumSize; i++) {
-            blsWorker.GenerateContributions(quorumSize / 2 + 1, ids, members[i].vvec, members[i].skShares);
+        for (auto& member : members) {
+            blsWorker.GenerateContributions(quorumSize / 2 + 1, ids, member.vvec, member.skShares);
         }
     }
     ~DKG()
@@ -93,7 +94,7 @@ class DKG
             ReceiveShares(memberIdx);
 
             std::set<size_t> invalidIndexes;
-            for (int i = 0; i < invalidCount; i++) {
+            for ([[maybe_unused]] const auto _ : irange::range(invalidCount)) {
                 int shareIdx = GetRandInt(receivedSkShares.size());
                 receivedSkShares[shareIdx].MakeNewKey();
                 invalidIndexes.emplace(shareIdx);
@@ -112,15 +113,15 @@ static void BLSDKG_GenerateContributions(benchmark::Bench& bench, uint32_t epoch
     blsWorker.Start();
     std::vector<CBLSId> ids;
     std::vector<Member> members;
-    for (int i = 0; i < quorumSize; i++) {
+    for (const int i : irange::range(quorumSize)) {
         uint256 id;
         WriteLE64(id.begin(), i + 1);
         members.push_back({CBLSId(id), {}, {}});
         ids.emplace_back(id);
     }
     bench.minEpochIterations(epoch_iters).run([&blsWorker, &quorumSize, &ids, &members] {
-        for (int i = 0; i < quorumSize; i++) {
-            blsWorker.GenerateContributions(quorumSize / 2 + 1, ids, members[i].vvec, members[i].skShares);
+        for (auto& member : members) {
+            blsWorker.GenerateContributions(quorumSize / 2 + 1, ids, member.vvec, member.skShares);
         }
     });
     blsWorker.Stop();
diff --git a/src/coinjoin/client.cpp b/src/coinjoin/client.cpp
index 49f002bde8059..9ed6170fef344 100644
--- a/src/coinjoin/client.cpp
+++ b/src/coinjoin/client.cpp
@@ -15,6 +15,7 @@
 #include <netmessagemaker.h>
 #include <script/sign.h>
 #include <shutdown.h>
+#include <util/irange.h>
 #include <util/moneystr.h>
 #include <util/ranges.h>
 #include <util/system.h>
@@ -579,7 +580,8 @@ bool CCoinJoinClientSession::SignFinalTransaction(const CTransaction& finalTrans
             int nMyInputIndex = -1;
             CScript prevPubKey = CScript();
 
-            for (unsigned int i = 0; i < finalMutableTransaction.vin.size(); i++) {
+            for (const auto i : irange::range(finalMutableTransaction.vin.size())) {
+                // cppcheck-suppress useStlAlgorithm
                 if (finalMutableTransaction.vin[i] == txdsin) {
                     nMyInputIndex = i;
                     prevPubKey = txdsin.prevPubKey;
@@ -1222,7 +1224,7 @@ bool CCoinJoinClientSession::SubmitDenominate(CConnman& connman)
 
     std::vector<std::pair<int, size_t> > vecInputsByRounds;
 
-    for (int i = 0; i < CCoinJoinClientOptions::GetRounds() + CCoinJoinClientOptions::GetRandomRounds(); i++) {
+    for (const auto i : irange::range(CCoinJoinClientOptions::GetRounds() + CCoinJoinClientOptions::GetRandomRounds())) {
         if (PrepareDenominate(i, i, strError, vecTxDSIn, vecPSInOutPairsTmp, true)) {
             LogPrint(BCLog::COINJOIN, "CCoinJoinClientSession::SubmitDenominate -- Running CoinJoin denominate for %d rounds, success\n", i);
             vecInputsByRounds.emplace_back(i, vecPSInOutPairsTmp.size());
@@ -1712,7 +1714,7 @@ bool CCoinJoinClientSession::CreateDenominated(CAmount nBalanceToDenominate, con
             LogPrint(BCLog::COINJOIN, "CCoinJoinClientSession::%s -- 2 - nBalanceToDenominate: %f, nDenomValue: %f, denomsToCreateValue: %d, denomsToCreateBal: %d\n",
                                          __func__, (float) nBalanceToDenominate / COIN, (float) nDenomValue / COIN, denomsToCreateValue, denomsToCreateBal);
             auto it = mapDenomCount.find(nDenomValue);
-            for (int i = 0; i < denomsToCreate; i++) {
+            for (const auto i : irange::range(denomsToCreate)) {
                 // Never go above the cap unless it's the largest denom
                 if (nDenomValue != nLargestDenomValue && it->second >= CCoinJoinClientOptions::GetDenomsHardCap()) break;
 
diff --git a/src/coinjoin/server.cpp b/src/coinjoin/server.cpp
index 8a2a8b2c6a45f..08e794d039da5 100644
--- a/src/coinjoin/server.cpp
+++ b/src/coinjoin/server.cpp
@@ -4,20 +4,20 @@
 
 #include <coinjoin/server.h>
 
-#include <masternode/node.h>
-#include <evo/deterministicmns.h>
 #include <consensus/validation.h>
 #include <core_io.h>
+#include <evo/deterministicmns.h>
 #include <masternode/meta.h>
+#include <masternode/node.h>
 #include <masternode/sync.h>
 #include <net_processing.h>
 #include <netmessagemaker.h>
 #include <script/interpreter.h>
 #include <shutdown.h>
 #include <txmempool.h>
+#include <util/moneystr.h>
 #include <util/ranges.h>
 #include <util/system.h>
-#include <util/moneystr.h>
 #include <validation.h>
 #include <version.h>
 
@@ -272,11 +272,11 @@ void CCoinJoinServer::CreateFinalTransaction(CConnman& connman)
     CMutableTransaction txNew;
 
     // make our new transaction
-    for (int i = 0; i < GetEntriesCountLocked(); i++) {
-        for (const auto& txout : vecEntries[i].vecTxOut) {
+    for (const auto& entry : vecEntries) {
+        for (const auto& txout : entry.vecTxOut) {
             txNew.vout.push_back(txout);
         }
-        for (const auto& txdsin : vecEntries[i].vecTxDSIn) {
+        for (const auto& txdsin : entry.vecTxDSIn) {
             txNew.vin.push_back(txdsin);
         }
     }
@@ -632,8 +632,8 @@ bool CCoinJoinServer::AddScriptSig(const CTxIn& txinNew)
             LogPrint(BCLog::COINJOIN, "CCoinJoinServer::AddScriptSig -- adding to finalMutableTransaction, scriptSig=%s\n", ScriptToAsmStr(txinNew.scriptSig).substr(0, 24));
         }
     }
-    for (int i = 0; i < GetEntriesCountLocked(); i++) {
-        if (vecEntries[i].AddScriptSig(txinNew)) {
+    for (auto& entry : vecEntries) {
+        if (entry.AddScriptSig(txinNew)) {
             LogPrint(BCLog::COINJOIN, "CCoinJoinServer::AddScriptSig -- adding to entries, scriptSig=%s\n", ScriptToAsmStr(txinNew.scriptSig).substr(0, 24));
             return true;
         }
diff --git a/src/llmq/blockprocessor.cpp b/src/llmq/blockprocessor.cpp
index 341a716add971..3dd11be9d6c9e 100644
--- a/src/llmq/blockprocessor.cpp
+++ b/src/llmq/blockprocessor.cpp
@@ -16,9 +16,10 @@
 #include <net_processing.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
-#include <validation.h>
 #include <saltedhasher.h>
 #include <sync.h>
+#include <util/irange.h>
+#include <validation.h>
 
 #include <map>
 
@@ -446,7 +447,7 @@ bool CQuorumBlockProcessor::IsCommitmentRequired(const Consensus::LLMQParams& ll
     assert(nHeight <= ::ChainActive().Height() + 1);
     const auto *const pindex = ::ChainActive().Height() < nHeight ? ::ChainActive().Tip() : ::ChainActive().Tip()->GetAncestor(nHeight);
 
-    for (int quorumIndex = 0; quorumIndex < llmqParams.signingActiveQuorumCount; ++quorumIndex) {
+    for (const auto quorumIndex : irange::range(llmqParams.signingActiveQuorumCount)) {
         uint256 quorumHash = GetQuorumBlockHash(llmqParams, nHeight, quorumIndex);
         if (quorumHash.IsNull()) return false;
         if (HasMinedCommitment(llmqParams.type, quorumHash)) return false;
@@ -600,7 +601,7 @@ std::vector<std::pair<int, const CBlockIndex*>> CQuorumBlockProcessor::GetLastMi
     const Consensus::LLMQParams& llmqParams = GetLLMQParams(llmqType);
     std::vector<std::pair<int, const CBlockIndex*>> ret;
 
-    for (int quorumIndex = 0; quorumIndex < llmqParams.signingActiveQuorumCount; ++quorumIndex) {
+    for (const auto quorumIndex : irange::range(llmqParams.signingActiveQuorumCount)) {
         std::optional<const CBlockIndex*> q = GetLastMinedCommitmentsByQuorumIndexUntilBlock(llmqType, pindex, quorumIndex, cycle);
         if (q.has_value()) {
             ret.emplace_back(quorumIndex, q.value());
@@ -728,7 +729,7 @@ std::optional<std::vector<CFinalCommitment>> CQuorumBlockProcessor::GetMineableC
     const auto *const pindex = ::ChainActive().Height() < nHeight ? ::ChainActive().Tip() : ::ChainActive().Tip()->GetAncestor(nHeight);
 
     std::stringstream ss;
-    for (int quorumIndex = 0; quorumIndex < llmqParams.signingActiveQuorumCount; ++quorumIndex) {
+    for (const auto quorumIndex : irange::range(llmqParams.signingActiveQuorumCount)) {
         CFinalCommitment cf;
 
         uint256 quorumHash = GetQuorumBlockHash(llmqParams, nHeight, quorumIndex);
diff --git a/src/llmq/commitment.cpp b/src/llmq/commitment.cpp
index de00ea49a9574..a01f96c6e163b 100644
--- a/src/llmq/commitment.cpp
+++ b/src/llmq/commitment.cpp
@@ -10,6 +10,7 @@
 #include <chainparams.h>
 #include <consensus/validation.h>
 #include <logging.h>
+#include <util/irange.h>
 #include <validation.h>
 
 namespace llmq
@@ -80,16 +81,16 @@ bool CFinalCommitment::Verify(const CBlockIndex* pQuorumBaseBlockIndex, bool che
     }
     auto members = CLLMQUtils::GetAllQuorumMembers(llmqType, pQuorumBaseBlockIndex);
     std::stringstream ss;
-    for (size_t i = 0; i < llmq_params.size; i++) {
+    for (const auto i : irange::range(llmq_params.size)) {
         ss << "v[" << i << "]=" << validMembers[i];
     }
     std::stringstream ss2;
-    for (size_t i = 0; i < llmq_params.size; i++) {
+    for (const auto i : irange::range(llmq_params.size)) {
         ss2 << "s[" << i << "]=" << signers[i];
     }
 
     LogPrintfFinalCommitment("CFinalCommitment::%s mns[%d] validMembers[%s] signers[%s]\n", __func__, members.size(), ss.str(), ss2.str());
-    for (size_t i = members.size(); i < size_t(llmq_params.size); i++) {
+    for (const auto i : irange::range(members.size(), size_t(llmq_params.size))) {
         if (validMembers[i]) {
             LogPrintfFinalCommitment("q[%s] invalid validMembers bitset. bit %d should not be set\n", quorumHash.ToString(), i);
             return false;
@@ -109,7 +110,7 @@ bool CFinalCommitment::Verify(const CBlockIndex* pQuorumBaseBlockIndex, bool che
         }
         LogPrintfFinalCommitment("CFinalCommitment::%s members[%s] quorumPublicKey[%s] commitmentHash[%s]\n", __func__, ss3.str(), quorumPublicKey.ToString(), commitmentHash.ToString());
         std::vector<CBLSPublicKey> memberPubKeys;
-        for (size_t i = 0; i < members.size(); i++) {
+        for (const auto i : irange::range(members.size())) {
             if (!signers[i]) {
                 continue;
             }
@@ -168,7 +169,7 @@ bool CheckLLMQCommitment(const CTransaction& tx, const CBlockIndex* pindexPrev,
     }
     const auto& llmq_params = GetLLMQParams(qcTx.commitment.llmqType);
     std::stringstream ss;
-    for (size_t i = 0; i < llmq_params.size; i++) {
+    for (const auto i : irange::range(llmq_params.size)) {
         ss << "v[" << i << "]=" << qcTx.commitment.validMembers[i];
     }
     LogPrintfFinalCommitment("%s llmqType[%d] validMembers[%s] signers[]\n", __func__, int(qcTx.commitment.llmqType), ss.str());
diff --git a/src/llmq/debug.cpp b/src/llmq/debug.cpp
index 4d97abeb11232..ee93d879cbb92 100644
--- a/src/llmq/debug.cpp
+++ b/src/llmq/debug.cpp
@@ -10,6 +10,7 @@
 
 #include <evo/deterministicmns.h>
 #include <llmq/utils.h>
+#include <util/irange.h>
 
 namespace llmq
 {
@@ -79,7 +80,7 @@ UniValue CDKGDebugSessionStatus::ToJson(int quorumIndex, int detailLevel) const
         }
     };
 
-    for (size_t i = 0; i < members.size(); i++) {
+    for (const auto i : irange::range(members.size())) {
         const auto& m = members[i];
         add(badMembers, i, m.bad);
         add(weComplain, i, m.weComplain);
diff --git a/src/llmq/dkgsession.cpp b/src/llmq/dkgsession.cpp
index 17bfc58b54bc3..cefa8d346722e 100644
--- a/src/llmq/dkgsession.cpp
+++ b/src/llmq/dkgsession.cpp
@@ -20,6 +20,7 @@
 
 #include <cxxtimer.hpp>
 #include <memory>
+#include <util/irange.h>
 
 namespace llmq
 {
@@ -79,14 +80,14 @@ bool CDKGSession::Init(const CBlockIndex* _pQuorumBaseBlockIndex, const std::vec
     receivedSkContributions.resize(members.size());
     vecEncryptedContributions.resize(members.size());
 
-    for (size_t i = 0; i < mns.size(); i++) {
+    for (const auto i : irange::range(mns.size())) {
         members[i] = std::make_unique<CDKGMember>(mns[i], i);
         membersMap.emplace(members[i]->dmn->proTxHash, i);
         memberIds[i] = members[i]->id;
     }
 
     if (!_myProTxHash.IsNull()) {
-        for (size_t i = 0; i < members.size(); i++) {
+        for (const auto i : irange::range(members.size())) {
             const auto& m = members[i];
             if (m->dmn->proTxHash == _myProTxHash) {
                 myIdx = i;
@@ -176,7 +177,7 @@ void CDKGSession::SendContributions(CDKGPendingMessages& pendingMessages)
     qc.contributions = std::make_shared<CBLSIESMultiRecipientObjects<CBLSSecretKey>>();
     qc.contributions->InitEncrypt(members.size());
 
-    for (size_t i = 0; i < members.size(); i++) {
+    for (const auto i : irange::range(members.size())) {
         const auto& m = members[i];
         CBLSSecretKey skContrib = skContributions[i];
 
@@ -383,7 +384,7 @@ void CDKGSession::VerifyPendingContributions()
         return;
     }
 
-    for (size_t i = 0; i < memberIndexes.size(); i++) {
+    for (const auto i : irange::range(memberIndexes.size())) {
         if (!result[i]) {
             const auto& m = members[memberIndexes[i]];
             logger.Batch("invalid contribution from %s. will complain later", m->dmn->proTxHash.ToString());
@@ -493,7 +494,7 @@ void CDKGSession::SendComplaint(CDKGPendingMessages& pendingMessages)
 
     int badCount = 0;
     int complaintCount = 0;
-    for (size_t i = 0; i < members.size(); i++) {
+    for (const auto i : irange::range(members.size())) {
         const auto& m = members[i];
         if (m->bad || m->badConnection) {
             qc.badMembers[i] = true;
@@ -601,7 +602,7 @@ void CDKGSession::ReceiveMessage(const CDKGComplaint& qc, bool& retBan)
     }
 
     int receivedCount = 0;
-    for (size_t i = 0; i < members.size(); i++) {
+    for (const auto i : irange::range(members.size())) {
         const auto& m = members[i];
         if (qc.badMembers[i]) {
             logger.Batch("%s voted for %s to be bad", member->dmn->proTxHash.ToString(), m->dmn->proTxHash.ToString());
@@ -682,7 +683,7 @@ void CDKGSession::SendJustification(CDKGPendingMessages& pendingMessages, const
     qj.proTxHash = myProTxHash;
     qj.contributions.reserve(forMembers.size());
 
-    for (size_t i = 0; i < members.size(); i++) {
+    for (const auto i : irange::range(members.size())) {
         const auto& m = members[i];
         if (!forMembers.count(m->dmn->proTxHash)) {
             continue;
@@ -929,7 +930,7 @@ void CDKGSession::SendCommitment(CDKGPendingMessages& pendingMessages)
     qc.quorumHash = m_quorum_base_block_index->GetBlockHash();
     qc.proTxHash = myProTxHash;
 
-    for (size_t i = 0; i < members.size(); i++) {
+    for (const auto i : irange::range(members.size())) {
         const auto& m = members[i];
         if (!m->bad) {
             qc.validMembers[i] = true;
@@ -1069,7 +1070,8 @@ bool CDKGSession::PreVerifyMessage(const CDKGPrematureCommitment& qc, bool& retB
         return false;
     }
 
-    for (size_t i = members.size(); i < size_t(params.size); i++) {
+    for (const auto i : irange::range(members.size(), size_t(params.size))) {
+        // cppcheck-suppress useStlAlgorithm
         if (qc.validMembers[i]) {
             retBan = true;
             logger.Batch("invalid validMembers bitset. bit %d should not be set", i);
diff --git a/src/llmq/dkgsessionmgr.cpp b/src/llmq/dkgsessionmgr.cpp
index ed88ed95a15e9..694c56670f42c 100644
--- a/src/llmq/dkgsessionmgr.cpp
+++ b/src/llmq/dkgsessionmgr.cpp
@@ -12,6 +12,7 @@
 #include <chainparams.h>
 #include <net_processing.h>
 #include <spork.h>
+#include <util/irange.h>
 #include <validation.h>
 
 namespace llmq
@@ -32,7 +33,7 @@ CDKGSessionManager::CDKGSessionManager(CConnman& _connman, CBLSWorker& _blsWorke
     const Consensus::Params& consensus_params = Params().GetConsensus();
     for (const auto& params : consensus_params.llmqs) {
         auto session_count = (params.type == consensus_params.llmqTypeDIP0024InstantSend) ? params.signingActiveQuorumCount : 1;
-        for (int i = 0; i < session_count; ++i) {
+        for (const auto i : irange::range(session_count)) {
             dkgSessionHandlers.emplace(std::piecewise_construct,
                                        std::forward_as_tuple(params.type, i),
                                        std::forward_as_tuple(params, blsWorker, *this, connman, i));
@@ -381,7 +382,7 @@ bool CDKGSessionManager::GetVerifiedContributions(Consensus::LLMQType llmqType,
     memberIndexesRet.reserve(members.size());
     vvecsRet.reserve(members.size());
     skContributionsRet.reserve(members.size());
-    for (size_t i = 0; i < members.size(); i++) {
+    for (const auto i : irange::range(members.size())) {
         if (validMembers[i]) {
             const uint256& proTxHash = members[i]->proTxHash;
             ContributionsCacheKey cacheKey = {llmqType, pQuorumBaseBlockIndex->GetBlockHash(), proTxHash};
@@ -413,7 +414,8 @@ bool CDKGSessionManager::GetEncryptedContributions(Consensus::LLMQType llmqType,
     vecRet.reserve(members.size());
 
     size_t nRequestedMemberIdx{std::numeric_limits<size_t>::max()};
-    for (size_t i = 0; i < members.size(); i++) {
+    for (const auto i : irange::range(members.size())) {
+        // cppcheck-suppress useStlAlgorithm
         if (members[i]->proTxHash == nProTxHash) {
             nRequestedMemberIdx = i;
             break;
@@ -423,7 +425,7 @@ bool CDKGSessionManager::GetEncryptedContributions(Consensus::LLMQType llmqType,
         return false;
     }
 
-    for (size_t i = 0; i < members.size(); i++) {
+    for (const auto i : irange::range(members.size())) {
         if (validMembers[i]) {
             CBLSIESMultiRecipientObjects<CBLSSecretKey> encryptedContributions;
             if (!db->Read(std::make_tuple(DB_ENC_CONTRIB, llmqType, pQuorumBaseBlockIndex->GetBlockHash(), members[i]->proTxHash), encryptedContributions)) {
diff --git a/src/llmq/instantsend.cpp b/src/llmq/instantsend.cpp
index c6827f4c20462..8bf9d0603dfa7 100644
--- a/src/llmq/instantsend.cpp
+++ b/src/llmq/instantsend.cpp
@@ -13,13 +13,14 @@
 #include <chainparams.h>
 #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>
-#include <validation.h>
+#include <txmempool.h>
+#include <util/irange.h>
+#include <util/ranges.h>
 #include <util/validation.h>
+#include <validation.h>
 
 #include <cxxtimer.hpp>
 
@@ -558,7 +559,7 @@ bool CInstantSendManager::TrySignInputLocks(const CTransaction& tx, bool fRetroa
     LogPrint(BCLog::INSTANTSEND, "CInstantSendManager::%s -- txid=%s: trying to vote on %d inputs\n", __func__,
              tx.GetHash().ToString(), tx.vin.size());
 
-    for (size_t i = 0; i < tx.vin.size(); i++) {
+    for (const auto i : irange::range(tx.vin.size())) {
         auto& in = tx.vin[i];
         auto& id = ids[i];
         WITH_LOCK(cs_inputReqests, inputRequestIds.emplace(id));
diff --git a/src/llmq/quorums.cpp b/src/llmq/quorums.cpp
index 593f1e2f26246..e9729ad943f63 100644
--- a/src/llmq/quorums.cpp
+++ b/src/llmq/quorums.cpp
@@ -12,13 +12,14 @@
 #include <evo/specialtx.h>
 #include <evo/deterministicmns.h>
 
-#include <masternode/node.h>
 #include <chainparams.h>
+#include <masternode/node.h>
 #include <masternode/sync.h>
 #include <net.h>
 #include <net_processing.h>
 #include <netmessagemaker.h>
 #include <univalue.h>
+#include <util/irange.h>
 #include <validation.h>
 
 #include <cxxtimer.hpp>
@@ -88,7 +89,8 @@ bool CQuorum::IsMember(const uint256& proTxHash) const
 
 bool CQuorum::IsValidMember(const uint256& proTxHash) const
 {
-    for (size_t i = 0; i < members.size(); i++) {
+    for (const auto i : irange::range(members.size())) {
+        // cppcheck-suppress useStlAlgorithm
         if (members[i]->proTxHash == proTxHash) {
             return qc->validMembers[i];
         }
@@ -119,9 +121,10 @@ CBLSSecretKey CQuorum::GetSkShare() const
 
 int CQuorum::GetMemberIndex(const uint256& proTxHash) const
 {
-    for (size_t i = 0; i < members.size(); i++) {
+    for (const auto i : irange::range(members.size())) {
+        // cppcheck-suppress useStlAlgorithm
         if (members[i]->proTxHash == proTxHash) {
-            return (int)i;
+            return int(i);
         }
     }
     return -1;
@@ -274,7 +277,7 @@ void CQuorumManager::EnsureQuorumConnections(const Consensus::LLMQParams& llmqPa
         int cycleIndexTipHeight = pindexNew->nHeight % llmqParams.dkgInterval;
         int cycleQuorumBaseHeight = pindexNew->nHeight - cycleIndexTipHeight;
         std::stringstream ss;
-        for (int quorumIndex = 0; quorumIndex < llmqParams.signingActiveQuorumCount; ++quorumIndex) {
+        for (const auto quorumIndex : irange::range(llmqParams.signingActiveQuorumCount)) {
             if (quorumIndex <= cycleIndexTipHeight) {
                 int curDkgHeight = cycleQuorumBaseHeight + quorumIndex;
                 auto curDkgBlock = pindexNew->GetAncestor(curDkgHeight)->GetBlockHash();
@@ -518,7 +521,8 @@ size_t CQuorumManager::GetQuorumRecoveryStartOffset(const CQuorumCPtr pQuorum, c
     size_t nIndex{0};
     {
         LOCK(activeMasternodeInfoCs);
-        for (size_t i = 0; i < vecProTxHashes.size(); ++i) {
+        for (const auto i : irange::range(vecProTxHashes.size())) {
+            // cppcheck-suppress useStlAlgorithm
             if (activeMasternodeInfo.proTxHash == vecProTxHashes[i]) {
                 nIndex = i;
                 break;
@@ -695,7 +699,7 @@ void CQuorumManager::ProcessMessage(CNode* pFrom, const std::string& msg_type, C
             BLSSecretKeyVector vecSecretKeys;
             vecSecretKeys.resize(vecEncrypted.size());
             auto secret = WITH_LOCK(activeMasternodeInfoCs, return *activeMasternodeInfo.blsKeyOperator);
-            for (size_t i = 0; i < vecEncrypted.size(); ++i) {
+            for (const auto i : irange::range(vecEncrypted.size())) {
                 if (!vecEncrypted[i].Decrypt(memberIdx, secret, vecSecretKeys[i], PROTOCOL_VERSION)) {
                     errorHandler("Failed to decrypt");
                     return;
@@ -724,7 +728,10 @@ void CQuorumManager::StartCachePopulatorThread(const CQuorumCPtr pQuorum) const
 
     // when then later some other thread tries to get keys, it will be much faster
     workerPool.push([pQuorum, t, this](int threadId) {
-        for (size_t i = 0; i < pQuorum->members.size() && !quorumThreadInterrupt; i++) {
+        for (const auto i : irange::range(pQuorum->members.size())) {
+            if (!quorumThreadInterrupt) {
+                break;
+            }
             if (pQuorum->qc->validMembers[i]) {
                 pQuorum->GetPubKeyShare(i);
             }
diff --git a/src/llmq/signing.cpp b/src/llmq/signing.cpp
index bbbc706b7c5b6..e2c308568b576 100644
--- a/src/llmq/signing.cpp
+++ b/src/llmq/signing.cpp
@@ -9,13 +9,14 @@
 #include <llmq/utils.h>
 #include <llmq/signing_shares.h>
 
-#include <masternode/node.h>
 #include <bls/bls_batchverifier.h>
 #include <chainparams.h>
 #include <cxxtimer.hpp>
+#include <masternode/node.h>
 #include <net_processing.h>
 #include <netmessagemaker.h>
 #include <scheduler.h>
+#include <util/irange.h>
 #include <validation.h>
 
 #include <algorithm>
@@ -1030,7 +1031,7 @@ CQuorumCPtr CSigningManager::SelectQuorumForSigning(Consensus::LLMQType llmqType
 
         std::vector<std::pair<uint256, size_t>> scores;
         scores.reserve(quorums.size());
-        for (size_t i = 0; i < quorums.size(); i++) {
+        for (const auto i : irange::range(quorums.size())) {
             CHashWriter h(SER_NETWORK, 0);
             h << llmqType;
             h << quorums[i]->qc->quorumHash;
diff --git a/src/llmq/signing_shares.cpp b/src/llmq/signing_shares.cpp
index 4e3c28b8d0d7e..03b2af47c24db 100644
--- a/src/llmq/signing_shares.cpp
+++ b/src/llmq/signing_shares.cpp
@@ -16,6 +16,7 @@
 #include <net_processing.h>
 #include <netmessagemaker.h>
 #include <spork.h>
+#include <util/irange.h>
 
 #include <cxxtimer.hpp>
 
@@ -38,7 +39,7 @@ std::string CSigSesAnn::ToString() const
 
 void CSigSharesInv::Merge(const CSigSharesInv& inv2)
 {
-    for (size_t i = 0; i < inv.size(); i++) {
+    for (const auto i : irange::range(inv.size())) {
         if (inv2.inv[i]) {
             inv[i] = inv2.inv[i];
         }
@@ -54,7 +55,7 @@ std::string CSigSharesInv::ToString() const
 {
     std::string str = "(";
     bool first = true;
-    for (size_t i = 0; i < inv.size(); i++) {
+    for (const auto i : irange::range(inv.size())) {
         if (!inv[i]) {
             continue;
         }
@@ -863,7 +864,7 @@ void CSigSharesManager::CollectSigSharesToRequest(std::unordered_map<NodeId, std
                 continue;
             }
 
-            for (size_t i = 0; i < session.announced.inv.size(); i++) {
+            for (const auto i : irange::range(session.announced.inv.size())) {
                 if (!session.announced.inv[i]) {
                     continue;
                 }
@@ -934,7 +935,7 @@ void CSigSharesManager::CollectSigSharesToSend(std::unordered_map<NodeId, std::u
 
             CBatchedSigShares batchedSigShares;
 
-            for (size_t i = 0; i < session.requested.inv.size(); i++) {
+            for (const auto i : irange::range(session.requested.inv.size())) {
                 if (!session.requested.inv[i]) {
                     continue;
                 }
@@ -1314,7 +1315,7 @@ void CSigSharesManager::Cleanup()
                 if (LogAcceptCategory(BCLog::LLMQ_SIGS)) {
                     if (const auto quorumIt = quorums.find(std::make_pair(oneSigShare.getLlmqType(), oneSigShare.getQuorumHash())); quorumIt != quorums.end()) {
                         const auto& quorum = quorumIt->second;
-                        for (size_t i = 0; i < quorum->members.size(); i++) {
+                        for (const auto i : irange::range(quorum->members.size())) {
                             if (m->count((uint16_t)i) == 0) {
                                 const auto& dmn = quorum->members[i];
                                 strMissingMembers += strprintf("\n  %s", dmn->proTxHash.ToString());
diff --git a/src/llmq/snapshot.cpp b/src/llmq/snapshot.cpp
index 0d031f491af7a..bdef5aa627360 100644
--- a/src/llmq/snapshot.cpp
+++ b/src/llmq/snapshot.cpp
@@ -29,12 +29,14 @@ void CQuorumSnapshot::ToJson(UniValue& obj) const
     obj.setObject();
     UniValue activeQ(UniValue::VARR);
     for (const auto& h : activeQuorumMembers) {
+        // cppcheck-suppress useStlAlgorithm
         activeQ.push_back(h);
     }
     obj.pushKV("activeQuorumMembers", activeQ);
     obj.pushKV("mnSkipListMode", mnSkipListMode);
     UniValue skipList(UniValue::VARR);
     for (const auto& h : mnSkipList) {
+        // cppcheck-suppress useStlAlgorithm
         skipList.push_back(h);
     }
     obj.pushKV("mnSkipList", skipList);
diff --git a/src/llmq/snapshot.h b/src/llmq/snapshot.h
index b4b6e0b93e4c2..0a046819afe41 100644
--- a/src/llmq/snapshot.h
+++ b/src/llmq/snapshot.h
@@ -12,6 +12,7 @@
 #include <serialize.h>
 #include <univalue.h>
 #include <unordered_lru_cache.h>
+#include <util/irange.h>
 
 #include <optional>
 
@@ -70,7 +71,7 @@ class CQuorumSnapshot
         size_t cnt = ReadCompactSize(s);
         ReadFixedBitSet(s, activeQuorumMembers, cnt);
         cnt = ReadCompactSize(s);
-        for (size_t i = 0; i < cnt; i++) {
+        for ([[maybe_unused]] const auto _ : irange::range(cnt)) {
             int obj;
             s >> obj;
             mnSkipList.push_back(obj);
@@ -175,21 +176,21 @@ class CQuorumRotationInfo
         }
 
         size_t cnt = ReadCompactSize(s);
-        for (size_t i = 0; i < cnt; i++) {
+        for ([[maybe_unused]] const auto _ : irange::range(cnt)) {
             uint256 hash;
             ::Unserialize(s, hash);
             lastQuorumHashPerIndex.push_back(std::move(hash));
         }
 
         cnt = ReadCompactSize(s);
-        for (size_t i = 0; i < cnt; i++) {
+        for ([[maybe_unused]] const auto _ : irange::range(cnt)) {
             CQuorumSnapshot snap;
             ::Unserialize(s, snap);
             quorumSnapshotList.push_back(std::move(snap));
         }
 
         cnt = ReadCompactSize(s);
-        for (size_t i = 0; i < cnt; i++) {
+        for ([[maybe_unused]] const auto _ : irange::range(cnt)) {
             CSimplifiedMNListDiff mnlist;
             ::Unserialize(s, mnlist);
             mnListDiffList.push_back(std::move(mnlist));
diff --git a/src/llmq/utils.cpp b/src/llmq/utils.cpp
index 3265fc0eab3c8..664993fab1bf8 100644
--- a/src/llmq/utils.cpp
+++ b/src/llmq/utils.cpp
@@ -18,6 +18,7 @@
 #include <random.h>
 #include <spork.h>
 #include <timedata.h>
+#include <util/irange.h>
 #include <util/ranges.h>
 #include <validation.h>
 #include <versionbits.h>
@@ -599,7 +600,7 @@ std::set<uint256> CLLMQUtils::GetQuorumRelayMembers(const Consensus::LLMQParams&
         return r;
     };
 
-    for (size_t i = 0; i < mns.size(); i++) {
+    for (const auto i : irange::range(mns.size())) {
         const auto& dmn = mns[i];
         if (dmn->proTxHash == forMember) {
             auto r = calcOutbound(i, dmn->proTxHash);
@@ -628,7 +629,7 @@ std::set<size_t> CLLMQUtils::CalcDeterministicWatchConnections(Consensus::LLMQTy
 
     std::set<size_t> result;
     uint256 rnd = qwatchConnectionSeed;
-    for (size_t i = 0; i < connectionCount; i++) {
+    for ([[maybe_unused]] const auto _ : irange::range(connectionCount)) {
         rnd = ::SerializeHash(std::make_pair(rnd, std::make_pair(llmqType, pQuorumBaseBlockIndex->GetBlockHash())));
         result.emplace(rnd.GetUint64(0) % memberCount);
     }
diff --git a/src/llmq/utils.h b/src/llmq/utils.h
index 065d4fa92ab4d..64ca37ef93e18 100644
--- a/src/llmq/utils.h
+++ b/src/llmq/utils.h
@@ -6,6 +6,7 @@
 #define BITCOIN_LLMQ_UTILS_H
 
 #include <consensus/params.h>
+#include <util/irange.h>
 
 #include <dbwrapper.h>
 #include <random.h>
@@ -133,7 +134,7 @@ class CLLMQUtils
     static std::string ToHexStr(const std::vector<bool>& vBits)
     {
         std::vector<uint8_t> vBytes((vBits.size() + 7) / 8);
-        for (size_t i = 0; i < vBits.size(); i++) {
+        for (const auto i : irange::range(vBits.size())) {
             vBytes[i / 8] |= vBits[i] << (i % 8);
         }
         return HexStr(vBytes);
diff --git a/src/util/irange.h b/src/util/irange.h
new file mode 100644
index 0000000000000..55eb8b5eb4ff8
--- /dev/null
+++ b/src/util/irange.h
@@ -0,0 +1,89 @@
+// 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.
+// Original implementation here: https://github.com/whoshuu/cpp_range/blob/cd6897e40176c3031ad1e4c8069d672b2e544996/include/range.h under MIT software license
+
+#ifndef BITCOIN_UTIL_IRANGE_H
+#define BITCOIN_UTIL_IRANGE_H
+
+#include <iterator>
+#include <stdexcept>
+
+namespace irange {
+namespace detail {
+
+template <typename T>
+class Range {
+    // T must be an integral type
+    static_assert(std::is_integral<T>());
+
+public:
+    Range(const T start, const T stop, const T step) : start_{start}, stop_{stop}, step_{step} {
+        if (step_ == 0) {
+            throw std::invalid_argument("Range step argument must not be zero");
+        } else {
+            if ((start_ > stop_ && step_ > 0) || (start_ < stop_ && step_ < 0)) {
+                throw std::invalid_argument("Range arguments must result in termination");
+            }
+        }
+    }
+
+    class iterator {
+    public:
+        typedef std::forward_iterator_tag iterator_category;
+        typedef T value_type;
+        typedef T& reference;
+        typedef T* pointer;
+
+        iterator(value_type value, value_type step, value_type boundary) : value_{value}, step_{step},
+                                                                           boundary_{boundary},
+                                                                           positive_step_(step_ > 0) {}
+        iterator operator++() { value_ += step_; return *this; }
+        reference operator*() { return value_; }
+        const pointer operator->() { return &value_; }
+        bool operator==(const iterator& rhs) { return positive_step_ ? (value_ >= rhs.value_ && value_ > boundary_)
+                                                                     : (value_ <= rhs.value_ && value_ < boundary_); }
+        bool operator!=(const iterator& rhs) { return positive_step_ ? (value_ < rhs.value_ && value_ >= boundary_)
+                                                                     : (value_ > rhs.value_ && value_ <= boundary_); }
+
+    private:
+        value_type value_;
+        const T step_;
+        const T boundary_;
+        const bool positive_step_;
+    };
+
+    iterator begin() const {
+        return iterator(start_, step_, start_);
+    }
+
+    iterator end() const {
+        return iterator(stop_, step_, start_);
+    }
+
+private:
+    const T start_;
+    const T stop_;
+    const T step_;
+};
+
+} // namespace detail
+
+template <typename T>
+detail::Range<T> range(const T stop) {
+    return detail::Range<T>(T{0}, stop, T{1});
+}
+
+template <typename T>
+detail::Range<T> range(const T start, const T stop) {
+    return detail::Range<T>(start, stop, T{1});
+}
+
+template <typename T>
+detail::Range<T> range(const T start, const T stop, const T step) {
+    return detail::Range<T>(start, stop, step);
+}
+
+} // namespace irange
+
+#endif // BITCOIN_UTIL_IRANGE_H
diff --git a/test/lint/lint-cppcheck-dash.sh b/test/lint/lint-cppcheck-dash.sh
index 45996efdb4d3b..ec9f145648aff 100755
--- a/test/lint/lint-cppcheck-dash.sh
+++ b/test/lint/lint-cppcheck-dash.sh
@@ -34,8 +34,8 @@ IGNORED_WARNINGS=(
     "src/test/dip0020opcodes_tests.cpp:.* warning: There is an unknown macro here somewhere. Configuration is required. If BOOST_FIXTURE_TEST_SUITE is a macro then please configure it."
     "src/ctpl_stl.h:.*22: warning: Dereferencing '_f' after it is deallocated / released"
 
-    "src/llmq/snapshot.cpp:.*:17: warning: Consider using std::copy algorithm instead of a raw loop."
-    "src/llmq/snapshot.cpp:.*:18: warning: Consider using std::copy algorithm instead of a raw loop."
+#    "src/llmq/snapshot.cpp:.*:17: warning: Consider using std::copy algorithm instead of a raw loop."
+#    "src/llmq/snapshot.cpp:.*:18: warning: Consider using std::copy algorithm instead of a raw loop."
 
 # General catchall, for some reason any value named 'hash' is viewed as never used.
     "Variable 'hash' is assigned a value that is never used."
@@ -109,7 +109,7 @@ ENABLED_CHECKS_REGEXP=$(join_array "|" "${ENABLED_CHECKS[@]}")
 IGNORED_WARNINGS_REGEXP=$(join_array "|" "${IGNORED_WARNINGS[@]}")
 FILES_REGEXP=$(join_array "|" "${FILES[@]}")
 WARNINGS=$(echo "${FILES}" | \
-    xargs cppcheck --enable=all -j "$(getconf _NPROCESSORS_ONLN)" --language=c++ --std=c++17 --template=gcc -D__cplusplus -DENABLE_WALLET -DCLIENT_VERSION_BUILD -DCLIENT_VERSION_IS_RELEASE -DCLIENT_VERSION_MAJOR -DCLIENT_VERSION_MINOR -DCLIENT_VERSION_REVISION -DCOPYRIGHT_YEAR -DDEBUG -DHAVE_WORKING_BOOST_SLEEP_FOR -DCHAR_BIT=8 -I src/ -q 2>&1 | sort -u | \
+    xargs cppcheck --enable=all --inline-suppr -j "$(getconf _NPROCESSORS_ONLN)" --language=c++ --std=c++17 --template=gcc -D__cplusplus -DENABLE_WALLET -DCLIENT_VERSION_BUILD -DCLIENT_VERSION_IS_RELEASE -DCLIENT_VERSION_MAJOR -DCLIENT_VERSION_MINOR -DCLIENT_VERSION_REVISION -DCOPYRIGHT_YEAR -DDEBUG -DHAVE_WORKING_BOOST_SLEEP_FOR -DCHAR_BIT=8 -I src/ -q 2>&1 | sort -u | \
     grep -E "${ENABLED_CHECKS_REGEXP}" | \
     grep -vE "${IGNORED_WARNINGS_REGEXP}" | \
     grep -E "${FILES_REGEXP}")