diff --git a/src/avalanche/peermanager.cpp b/src/avalanche/peermanager.cpp
--- a/src/avalanche/peermanager.cpp
+++ b/src/avalanche/peermanager.cpp
@@ -9,6 +9,7 @@
 #include <avalanche/delegation.h>
 #include <avalanche/validation.h>
 #include <cashaddrenc.h>
+#include <consensus/activation.h>
 #include <logging.h>
 #include <random.h>
 #include <scheduler.h>
@@ -980,22 +981,34 @@
     // previous block or lacking node connected.
     // The previous block time is capped to now for the unlikely event the
     // previous block time is in the future.
+    std::chrono::seconds registrationDelay =
+        std::chrono::duration_cast<std::chrono::seconds>(
+            IsLeeKuanYewEnabled(chainman.GetConsensus(), pprev)
+                ? 4 * Peer::DANGLING_TIMEOUT
+                : 2 * Peer::DANGLING_TIMEOUT);
+    std::chrono::seconds maxRegistrationDelay =
+        std::chrono::duration_cast<std::chrono::seconds>(
+            IsLeeKuanYewEnabled(chainman.GetConsensus(), pprev)
+                ? 6 * Peer::DANGLING_TIMEOUT
+                : 4 * Peer::DANGLING_TIMEOUT);
+    std::chrono::seconds minRegistrationDelay =
+        std::chrono::duration_cast<std::chrono::seconds>(
+            2 * Peer::DANGLING_TIMEOUT);
+
+    const int64_t targetRegistrationTime =
+        std::min(pprev->GetBlockTime(), GetTime()) - registrationDelay.count();
     const int64_t maxRegistrationTime =
         std::min(pprev->GetBlockTime(), GetTime()) -
-        std::chrono::duration_cast<std::chrono::seconds>(2 *
-                                                         Peer::DANGLING_TIMEOUT)
-            .count();
-
-    const int64_t recentRegistrationTime =
+        minRegistrationDelay.count();
+    const int64_t minRegistrationTime =
         std::min(pprev->GetBlockTime(), GetTime()) -
-        std::chrono::duration_cast<std::chrono::seconds>(4 *
-                                                         Peer::DANGLING_TIMEOUT)
-            .count();
+        maxRegistrationDelay.count();
 
     const BlockHash prevblockhash = pprev->GetBlockHash();
 
-    winners.clear();
-    while (winners.size() < peers.size()) {
+    std::vector<ProofRef> selectedProofs;
+    ProofRef firstCompliantProof = ProofRef();
+    while (selectedProofs.size() < peers.size()) {
         double bestRewardRank = std::numeric_limits<double>::max();
         ProofRef selectedProof = ProofRef();
         int64_t selectedProofRegistrationTime{0};
@@ -1012,8 +1025,10 @@
                 continue;
             }
 
-            if (std::find(winners.begin(), winners.end(),
-                          peer.proof->getPayoutScript()) != winners.end()) {
+            if (std::find_if(selectedProofs.begin(), selectedProofs.end(),
+                             [&peer](const ProofRef &proof) {
+                                 return peer.getProofId() == proof->getId();
+                             }) != selectedProofs.end()) {
                 continue;
             }
 
@@ -1070,15 +1085,41 @@
             break;
         }
 
-        winners.push_back(selectedProof->getPayoutScript());
+        if (!firstCompliantProof &&
+            selectedProofRegistrationTime < targetRegistrationTime) {
+            firstCompliantProof = selectedProof;
+        }
+
+        selectedProofs.push_back(selectedProof);
 
-        if (selectedProofRegistrationTime < recentRegistrationTime &&
+        if (selectedProofRegistrationTime < minRegistrationTime &&
             !isFlaky(selectedProof->getId())) {
             break;
         }
     }
 
-    return winners.size() > 0;
+    winners.clear();
+
+    if (!firstCompliantProof) {
+        return false;
+    }
+
+    winners.reserve(selectedProofs.size());
+
+    // Find the winner
+    for (const ProofRef &proof : selectedProofs) {
+        if (proof->getId() == firstCompliantProof->getId()) {
+            winners.push_back(proof->getPayoutScript());
+        }
+    }
+    // Add the others (if any) after the winner
+    for (const ProofRef &proof : selectedProofs) {
+        if (proof->getId() != firstCompliantProof->getId()) {
+            winners.push_back(proof->getPayoutScript());
+        }
+    }
+
+    return true;
 }
 
 bool PeerManager::isFlaky(const ProofId &proofid) const {
diff --git a/src/avalanche/test/peermanager_tests.cpp b/src/avalanche/test/peermanager_tests.cpp
--- a/src/avalanche/test/peermanager_tests.cpp
+++ b/src/avalanche/test/peermanager_tests.cpp
@@ -10,6 +10,7 @@
 #include <avalanche/test/util.h>
 #include <cashaddrenc.h>
 #include <config.h>
+#include <consensus/activation.h>
 #include <core_io.h>
 #include <key_io.h>
 #include <script/standard.h>
@@ -18,6 +19,7 @@
 #include <util/translation.h>
 #include <validation.h>
 
+#include <test/util/blockindex.h>
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
@@ -2536,6 +2538,7 @@
     }
 
     {
+        proofs.clear();
         for (size_t i = 0; i < 2; i++) {
             // Add a couple proofs
             const CKey key = CKey::MakeCompressedKey();
@@ -2549,6 +2552,8 @@
             BOOST_CHECK(pm.addNode(NodeId(i), proof->getId()));
 
             BOOST_CHECK(pm.setFinalized(peerid));
+
+            proofs.push_back(proof);
         }
 
         // The proofs has been registered > 30min from the previous block time,
@@ -2569,6 +2574,113 @@
         // Now only one is acceptable
         BOOST_CHECK(pm.selectStakingRewardWinner(&prevBlock, winners));
         BOOST_CHECK_EQUAL(winners.size(), 1);
+
+        // Remove all proofs
+        for (auto &proof : proofs) {
+            BOOST_CHECK(pm.rejectProof(
+                proof->getId(),
+                avalanche::PeerManager::RejectionMode::INVALIDATE));
+        }
+        BOOST_CHECK(!pm.selectStakingRewardWinner(&prevBlock, winners));
+    }
+
+    {
+        BOOST_CHECK_EQUAL(TestPeerManager::getPeerCount(pm), 0);
+
+        gArgs.ForceSetArg("-leekuanyewactivationtime", "0");
+
+        std::array<CBlockIndex, 12> blocks;
+        for (size_t i = 1; i < blocks.size(); ++i) {
+            blocks[i].pprev = &blocks[i - 1];
+        }
+        SetMTP(blocks, now.count());
+        prevBlock.pprev = &blocks.back();
+
+        BOOST_CHECK(IsLeeKuanYewEnabled(Params().GetConsensus(), &prevBlock));
+
+        proofs.clear();
+        for (size_t i = 0; i < 4; i++) {
+            // Add 4 proofs, registered at a 30 minutes interval
+            SetMockTime(now + i * 30min);
+
+            const CKey key = CKey::MakeCompressedKey();
+            CScript payoutScript = GetScriptForRawPubKey(key.GetPubKey());
+
+            auto proof = buildProofWithAmountAndPayout(PROOF_DUST_THRESHOLD,
+                                                       payoutScript);
+            PeerId peerid = TestPeerManager::registerAndGetPeerId(pm, proof);
+            BOOST_CHECK_NE(peerid, NO_PEER);
+            BOOST_CHECK(pm.forPeer(proof->getId(), [&](const Peer &peer) {
+                return peer.registration_time == now + i * 30min;
+            }));
+
+            BOOST_CHECK(pm.addNode(NodeId(i), proof->getId()));
+
+            BOOST_CHECK(pm.setFinalized(peerid));
+
+            proofs.push_back(proof);
+        }
+
+        // No proof has been registered before the previous block time
+        SetMockTime(now);
+        prevBlock.nTime = now.count();
+        BOOST_CHECK(!pm.selectStakingRewardWinner(&prevBlock, winners));
+
+        // 1 proof has been registered > 30min from the previous block time, but
+        // none > 60 minutes from the previous block time
+        // => we have no winner.
+        now += 30min + 1s;
+        SetMockTime(now);
+        prevBlock.nTime = now.count();
+        BOOST_CHECK(!pm.selectStakingRewardWinner(&prevBlock, winners));
+
+        // 1 proof has been registered > 60min but < 90min from the previous
+        // block time and 1 more has been registered > 30 minutes
+        // => we have a winner and one acceptable substitute.
+        now += 30min;
+        SetMockTime(now);
+        prevBlock.nTime = now.count();
+        BOOST_CHECK(pm.selectStakingRewardWinner(&prevBlock, winners));
+        BOOST_CHECK_EQUAL(winners.size(), 2);
+
+        // 1 proof has been registered > 60min but < 90min from the
+        // previous block time, 1 has been registered > 90 minutes and 1 more
+        // has been registered > 30 minutes
+        // => we have 1 winner and up to 2 acceptable substitutes.
+        now += 30min;
+        SetMockTime(now);
+        prevBlock.nTime = now.count();
+        BOOST_CHECK(pm.selectStakingRewardWinner(&prevBlock, winners));
+        BOOST_CHECK_LE(winners.size(), 3);
+
+        // 1 proofs has been registered > 60min but < 90min from the
+        // previous block time, 2 has been registered > 90 minutes and 1 more
+        // has been registered > 30 minutes
+        // => we have 1 winner, and up to 2 substitutes.
+        now += 30min;
+        SetMockTime(now);
+        prevBlock.nTime = now.count();
+        BOOST_CHECK(pm.selectStakingRewardWinner(&prevBlock, winners));
+        BOOST_CHECK_LE(winners.size(), 3);
+
+        // 1 proof has been registered > 60min but < 90min from the
+        // previous block time and 3 more has been registered > 90 minutes
+        // => we have 1 winner, and up to 1 substitute.
+        now += 30min;
+        SetMockTime(now);
+        prevBlock.nTime = now.count();
+        BOOST_CHECK(pm.selectStakingRewardWinner(&prevBlock, winners));
+        BOOST_CHECK_LE(winners.size(), 2);
+
+        // All proofs has been registered > 90min from the previous block time
+        // => we have 1 winner, and no substitute.
+        now += 30min;
+        SetMockTime(now);
+        prevBlock.nTime = now.count();
+        BOOST_CHECK(pm.selectStakingRewardWinner(&prevBlock, winners));
+        BOOST_CHECK_EQUAL(winners.size(), 1);
+
+        gArgs.ClearForcedArg("-leekuanyewactivationtime");
     }
 }
 
diff --git a/test/functional/abc_mining_stakingrewards.py b/test/functional/abc_mining_stakingrewards.py
--- a/test/functional/abc_mining_stakingrewards.py
+++ b/test/functional/abc_mining_stakingrewards.py
@@ -21,6 +21,7 @@
 
 QUORUM_NODE_COUNT = 16
 STAKING_REWARDS_COINBASE_RATIO_PERCENT = 10
+THE_FUTURE = 2000000000
 
 
 class AbcMiningStakingRewardsTest(BitcoinTestFramework):
@@ -35,6 +36,7 @@
                 "-avaminavaproofsnodecount=0",
                 "-whitelist=noban@127.0.0.1",
                 "-avalanchestakingrewards=1",
+                f"-leekuanyewactivationtime={THE_FUTURE}",
             ],
         ]
 
@@ -48,7 +50,7 @@
         quorum = [get_ava_p2p_interface(self, node) for _ in range(QUORUM_NODE_COUNT)]
         assert node.getavalancheinfo()["ready_to_poll"] is True
 
-        now += 60 * 60
+        now += 60 * 60 + 1
         node.setmocktime(now)
 
         invalid_block_hash = "0" * 63