diff --git a/src/avalanche/avalanche.h b/src/avalanche/avalanche.h
--- a/src/avalanche/avalanche.h
+++ b/src/avalanche/avalanche.h
@@ -24,6 +24,12 @@
  */
 static constexpr bool AVALANCHE_DEFAULT_PEER_DISCOVERY_ENABLED = false;
 
+/**
+ * Conflicting proofs cooldown time default value in seconds.
+ * Minimal delay between two proofs with at least a common UTXO.
+ */
+static constexpr size_t AVALANCHE_DEFAULT_CONFLICTING_PROOF_COOLDOWN = 60;
+
 /**
  * Avalanche default cooldown in milliseconds.
  */
diff --git a/src/avalanche/peermanager.h b/src/avalanche/peermanager.h
--- a/src/avalanche/peermanager.h
+++ b/src/avalanche/peermanager.h
@@ -78,10 +78,11 @@
     std::chrono::seconds registration_time;
     std::chrono::seconds nextPossibleConflictTime;
 
-    Peer(PeerId peerid_, ProofRef proof_)
+    Peer(PeerId peerid_, ProofRef proof_,
+         std::chrono::seconds nextPossibleConflictTime_)
         : peerid(peerid_), proof(std::move(proof_)),
           registration_time(GetTime<std::chrono::seconds>()),
-          nextPossibleConflictTime(registration_time) {}
+          nextPossibleConflictTime(std::move(nextPossibleConflictTime_)) {}
 
     const ProofId &getProofId() const { return proof->getId(); }
     uint32_t getScore() const { return proof->getScore(); }
@@ -112,6 +113,7 @@
     INVALID,
     CONFLICTING,
     REJECTED,
+    COOLDOWN_NOT_ELAPSED,
 };
 
 class ProofRegistrationState : public ValidationState<ProofRegistrationResult> {
diff --git a/src/avalanche/peermanager.cpp b/src/avalanche/peermanager.cpp
--- a/src/avalanche/peermanager.cpp
+++ b/src/avalanche/peermanager.cpp
@@ -4,6 +4,7 @@
 
 #include <avalanche/peermanager.h>
 
+#include <avalanche/avalanche.h>
 #include <avalanche/delegation.h>
 #include <avalanche/validation.h>
 #include <random.h>
@@ -204,10 +205,37 @@
         return invalidate(ProofRegistrationResult::INVALID, "invalid-proof");
     }
 
+    auto now = GetTime<std::chrono::seconds>();
+    auto nextCooldownTimePoint =
+        now + std::chrono::seconds(
+                  gArgs.GetArg("-avalancheconflictingproofcooldown",
+                               AVALANCHE_DEFAULT_CONFLICTING_PROOF_COOLDOWN));
+
     ProofPool::ConflictingProofSet conflictingProofs;
     switch (validProofPool.addProofIfNoConflict(proof, conflictingProofs)) {
         case ProofPool::AddProofStatus::REJECTED: {
             if (mode != RegistrationMode::FORCE_ACCEPT) {
+                auto bestPossibleConflictTime = std::chrono::seconds();
+                auto &pview = peers.get<by_proofid>();
+                for (auto &conflictingProof : conflictingProofs) {
+                    auto it = pview.find(conflictingProof->getId());
+                    assert(it != pview.end());
+
+                    // Search the most recent time over the peers
+                    bestPossibleConflictTime = std::max(
+                        bestPossibleConflictTime, it->nextPossibleConflictTime);
+
+                    updateNextPossibleConflictTime(it->peerid,
+                                                   nextCooldownTimePoint);
+                }
+
+                if (bestPossibleConflictTime > now) {
+                    // Cooldown not elapsed, reject the proof.
+                    return invalidate(
+                        ProofRegistrationResult::COOLDOWN_NOT_ELAPSED,
+                        "cooldown-not-elapsed");
+                }
+
                 // The proof has conflicts, move it to the conflicting proof
                 // pool so it can be pulled back if the conflicting ones are
                 // invalidated.
@@ -256,7 +284,7 @@
     const PeerId peerid = nextPeerId++;
 
     // We have no peer for this proof, time to create it.
-    auto inserted = peers.emplace(peerid, proof);
+    auto inserted = peers.emplace(peerid, proof, nextCooldownTimePoint);
     assert(inserted.second);
 
     // If there are nodes waiting for this proof, add them
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
@@ -8,6 +8,7 @@
 #include <avalanche/proofcomparator.h>
 #include <avalanche/test/util.h>
 #include <script/standard.h>
+#include <util/time.h>
 #include <util/translation.h>
 #include <validation.h>
 
@@ -44,6 +45,17 @@
 } // namespace
 } // namespace avalanche
 
+namespace {
+struct NoCoolDownFixture : public TestingSetup {
+    NoCoolDownFixture() {
+        gArgs.ForceSetArg("-avalancheconflictingproofcooldown", "0");
+    }
+    ~NoCoolDownFixture() {
+        gArgs.ClearForcedArg("-avalancheconflictingproofcooldown");
+    }
+};
+} // namespace
+
 BOOST_FIXTURE_TEST_SUITE(peermanager_tests, TestingSetup)
 
 BOOST_AUTO_TEST_CASE(select_peer_linear) {
@@ -810,7 +822,7 @@
     BOOST_CHECK(state.GetResult() == ProofRegistrationResult::INVALID);
 }
 
-BOOST_AUTO_TEST_CASE(conflicting_proof_rescan) {
+BOOST_FIXTURE_TEST_CASE(conflicting_proof_rescan, NoCoolDownFixture) {
     avalanche::PeerManager pm;
 
     const CKey key = CKey::MakeCompressedKey();
@@ -1029,7 +1041,7 @@
     BOOST_CHECK(!pm.exists(orphan20->getId()));
 }
 
-BOOST_AUTO_TEST_CASE(preferred_conflicting_proof) {
+BOOST_FIXTURE_TEST_CASE(preferred_conflicting_proof, NoCoolDownFixture) {
     avalanche::PeerManager pm;
 
     const CKey key = CKey::MakeCompressedKey();
@@ -1080,7 +1092,7 @@
     BOOST_CHECK(!pm.exists(proofSeq10->getId()));
 }
 
-BOOST_AUTO_TEST_CASE(update_next_conflict_time) {
+BOOST_FIXTURE_TEST_CASE(update_next_conflict_time, NoCoolDownFixture) {
     avalanche::PeerManager pm;
 
     auto now = GetTime<std::chrono::seconds>();
@@ -1113,7 +1125,7 @@
     checkNextPossibleConflictTime(now + std::chrono::seconds{1});
 }
 
-BOOST_AUTO_TEST_CASE(register_force_accept) {
+BOOST_FIXTURE_TEST_CASE(register_force_accept, NoCoolDownFixture) {
     avalanche::PeerManager pm;
 
     const CKey key = CKey::MakeCompressedKey();
@@ -1196,7 +1208,7 @@
     }
 }
 
-BOOST_AUTO_TEST_CASE(evicted_proof) {
+BOOST_FIXTURE_TEST_CASE(evicted_proof, NoCoolDownFixture) {
     avalanche::PeerManager pm;
 
     const CKey key = CKey::MakeCompressedKey();
@@ -1244,4 +1256,90 @@
     }
 }
 
+BOOST_AUTO_TEST_CASE(conflicting_proof_cooldown) {
+    avalanche::PeerManager pm;
+
+    const CKey key = CKey::MakeCompressedKey();
+
+    const Amount amount(10 * COIN);
+    const uint32_t height = 100;
+    const bool is_coinbase = false;
+    CScript script = GetScriptForDestination(PKHash(key.GetPubKey()));
+
+    const COutPoint conflictingOutpoint(TxId(GetRandHash()), 0);
+    {
+        LOCK(cs_main);
+        CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
+        coins.AddCoin(conflictingOutpoint,
+                      Coin(CTxOut(amount, script), height, is_coinbase), false);
+    }
+
+    auto buildProofWithSequence = [&](uint64_t sequence) {
+        ProofBuilder pb(sequence, 0, key);
+        BOOST_CHECK(
+            pb.addUTXO(conflictingOutpoint, amount, height, is_coinbase, key));
+        return pb.build();
+    };
+
+    auto proofSeq20 = buildProofWithSequence(20);
+    auto proofSeq30 = buildProofWithSequence(30);
+    auto proofSeq40 = buildProofWithSequence(40);
+
+    int64_t conflictingProofCooldown = 100;
+    gArgs.ForceSetArg("-avalancheconflictingproofcooldown",
+                      strprintf("%d", conflictingProofCooldown));
+
+    int64_t now = GetTime();
+
+    auto increaseMockTime = [&](int64_t s) {
+        now += s;
+        SetMockTime(now);
+    };
+    increaseMockTime(0);
+
+    BOOST_CHECK(pm.registerProof(proofSeq30));
+    BOOST_CHECK(pm.isBoundToPeer(proofSeq30->getId()));
+
+    auto checkRegistrationFailure = [&](const ProofRef &proof,
+                                        ProofRegistrationResult reason) {
+        ProofRegistrationState state;
+        BOOST_CHECK(!pm.registerProof(proof, state));
+        BOOST_CHECK(state.GetResult() == reason);
+    };
+
+    // Registering a conflicting proof will fail due to the conflicting proof
+    // cooldown
+    checkRegistrationFailure(proofSeq20,
+                             ProofRegistrationResult::COOLDOWN_NOT_ELAPSED);
+    BOOST_CHECK(!pm.exists(proofSeq20->getId()));
+
+    // The cooldown applies as well if the proof is the favorite
+    checkRegistrationFailure(proofSeq40,
+                             ProofRegistrationResult::COOLDOWN_NOT_ELAPSED);
+    BOOST_CHECK(!pm.exists(proofSeq40->getId()));
+
+    // Elapse the cooldown
+    increaseMockTime(conflictingProofCooldown);
+
+    // The proof will now be added to conflicting pool
+    checkRegistrationFailure(proofSeq20, ProofRegistrationResult::CONFLICTING);
+    BOOST_CHECK(pm.isInConflictingPool(proofSeq20->getId()));
+
+    // But no other
+    checkRegistrationFailure(proofSeq40,
+                             ProofRegistrationResult::COOLDOWN_NOT_ELAPSED);
+    BOOST_CHECK(!pm.exists(proofSeq40->getId()));
+    BOOST_CHECK(pm.isInConflictingPool(proofSeq20->getId()));
+
+    // Elapse the cooldown
+    increaseMockTime(conflictingProofCooldown);
+
+    // The proof will now be added to conflicting pool
+    checkRegistrationFailure(proofSeq40, ProofRegistrationResult::CONFLICTING);
+    BOOST_CHECK(pm.isInConflictingPool(proofSeq40->getId()));
+    BOOST_CHECK(!pm.exists(proofSeq20->getId()));
+
+    gArgs.ClearForcedArg("-avalancheconflictingproofcooldown");
+}
+
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/init.cpp b/src/init.cpp
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -1278,6 +1278,12 @@
                    strprintf("Enable avalanche peer discovery (default: %u)",
                              AVALANCHE_DEFAULT_PEER_DISCOVERY_ENABLED),
                    ArgsManager::ALLOW_ANY, OptionsCategory::AVALANCHE);
+    argsman.AddArg("-avalancheconflictingproofcooldown",
+                   strprintf("Mandatory cooldown before a proof conflicting "
+                             "with an already registered one can be considered "
+                             "in seconds (default: %u)",
+                             AVALANCHE_DEFAULT_CONFLICTING_PROOF_COOLDOWN),
+                   ArgsManager::ALLOW_INT, OptionsCategory::AVALANCHE);
     argsman.AddArg(
         "-avacooldown",
         strprintf("Mandatory cooldown between two avapoll (default: %u)",
diff --git a/test/functional/abc_p2p_avalanche_voting_proofs.py b/test/functional/abc_p2p_avalanche_voting_proofs.py
--- a/test/functional/abc_p2p_avalanche_voting_proofs.py
+++ b/test/functional/abc_p2p_avalanche_voting_proofs.py
@@ -26,7 +26,13 @@
         self.setup_clean_chain = True
         self.num_nodes = 1
         self.extra_args = [
-            ['-enableavalanche=1', '-avacooldown=0', '-whitelist=noban@127.0.0.1']]
+            [
+                '-enableavalanche=1',
+                '-avacooldown=0',
+                '-avalancheconflictingproofcooldown=0',
+                '-whitelist=noban@127.0.0.1',
+            ],
+        ]
         self.supports_cli = False
 
     def run_test(self):