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.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>
@@ -194,6 +195,31 @@
     switch (validProofPool.addProofIfNoConflict(proof, conflictingProofs)) {
         case ProofPool::AddProofStatus::REJECTED: {
             if (mode != FORCE_ACCEPT) {
+                auto now = GetTime<std::chrono::seconds>();
+                auto nextCooldownTimePoint =
+                    now + std::chrono::seconds(gArgs.GetArg(
+                              "-avalancheconflictingproofcooldown",
+                              AVALANCHE_DEFAULT_CONFLICTING_PROOF_COOLDOWN));
+
+                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 false;
+                }
+
                 // The proof has conflicts, move it to the conflicting proof
                 // pool so it can be pulled back if the conflicting ones are
                 // invalidated.
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) {
@@ -1011,7 +1023,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();
@@ -1178,4 +1190,88 @@
     }
 }
 
+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 proofSeq10 = buildProofWithSequence(10);
+    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()));
+
+    // Register a first conflicting proof should be no issue, ending in the
+    // conflicting pool
+    BOOST_CHECK(!pm.registerProof(proofSeq10));
+    BOOST_CHECK(pm.isInConflictingPool(proofSeq10->getId()));
+
+    // Registering another one will fail due to the conflicting proof cooldown
+    BOOST_CHECK(!pm.registerProof(proofSeq20));
+    BOOST_CHECK(!pm.exists(proofSeq20->getId()));
+    BOOST_CHECK(pm.isInConflictingPool(proofSeq10->getId()));
+
+    // The cooldown applies as well if the proof is the favorite
+    BOOST_CHECK(!pm.registerProof(proofSeq40));
+    BOOST_CHECK(!pm.exists(proofSeq40->getId()));
+    BOOST_CHECK(pm.isInConflictingPool(proofSeq10->getId()));
+
+    // Elapse the cooldown
+    increaseMockTime(conflictingProofCooldown);
+
+    // The proof will now be added to conflicting pool
+    BOOST_CHECK(!pm.registerProof(proofSeq20));
+    BOOST_CHECK(pm.isInConflictingPool(proofSeq20->getId()));
+    BOOST_CHECK(!pm.exists(proofSeq10->getId()));
+
+    // But no other
+    BOOST_CHECK(!pm.registerProof(proofSeq40));
+    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
+    BOOST_CHECK(!pm.registerProof(proofSeq40));
+    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
@@ -1270,6 +1270,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)",