diff --git a/src/avalanche/peermanager.cpp b/src/avalanche/peermanager.cpp
--- a/src/avalanche/peermanager.cpp
+++ b/src/avalanche/peermanager.cpp
@@ -167,9 +167,10 @@
         LOCK(cs_main);
 
         const CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
+        const CBlockIndex *pindex = ::ChainActive().Tip();
         for (const auto &p : peers) {
             ProofValidationState state;
-            if (!p.proof->verify(state, coins)) {
+            if (!p.proof->verify(state, coins, pindex)) {
                 invalidPeers.push_back(p.peerid);
             }
         }
@@ -206,9 +207,10 @@
         // Reject invalid proof.
         LOCK(cs_main);
         const CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
+        const CBlockIndex *pindex = ::ChainActive().Tip();
 
         ProofValidationState state;
-        if (!proof->verify(state, coins)) {
+        if (!proof->verify(state, coins, pindex)) {
             return peers.end();
         }
     }
diff --git a/src/avalanche/proof.h b/src/avalanche/proof.h
--- a/src/avalanche/proof.h
+++ b/src/avalanche/proof.h
@@ -17,6 +17,7 @@
 #include <cstdint>
 #include <vector>
 
+class CBlockIndex;
 class CCoinsView;
 
 /**
@@ -112,7 +113,8 @@
     uint32_t getScore() const;
 
     bool verify(ProofValidationState &state) const;
-    bool verify(ProofValidationState &state, const CCoinsView &view) const;
+    bool verify(ProofValidationState &state, const CCoinsView &view,
+                const CBlockIndex *pindex) const;
 };
 
 } // namespace avalanche
diff --git a/src/avalanche/proof.cpp b/src/avalanche/proof.cpp
--- a/src/avalanche/proof.cpp
+++ b/src/avalanche/proof.cpp
@@ -5,6 +5,7 @@
 #include <avalanche/proof.h>
 
 #include <avalanche/validation.h>
+#include <blockindex.h>
 #include <coins.h>
 #include <hash.h>
 #include <script/standard.h>
@@ -105,7 +106,8 @@
     return true;
 }
 
-bool Proof::verify(ProofValidationState &state, const CCoinsView &view) const {
+bool Proof::verify(ProofValidationState &state, const CCoinsView &view,
+                   const CBlockIndex *pindex) const {
     if (!verify(state)) {
         // state is set by verify.
         return false;
@@ -170,6 +172,12 @@
         }
     }
 
+    if (pindex->GetMedianTimePast() >= expirationTime) {
+        // Expiration time in the past.
+        return state.Invalid(ProofValidationResult::EXPIRED,
+                             "past-expiration-time");
+    }
+
     return true;
 }
 
diff --git a/src/avalanche/test/proof_tests.cpp b/src/avalanche/test/proof_tests.cpp
--- a/src/avalanche/test/proof_tests.cpp
+++ b/src/avalanche/test/proof_tests.cpp
@@ -7,11 +7,13 @@
 #include <avalanche/proofbuilder.h>
 #include <avalanche/test/util.h>
 #include <avalanche/validation.h>
+#include <blockindex.h>
 #include <coins.h>
 #include <script/standard.h>
 #include <streams.h>
 #include <util/strencodings.h>
 
+#include <test/util/block_utils.h>
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
@@ -328,6 +330,14 @@
     CCoinsView coinsDummy;
     CCoinsViewCache coins(&coinsDummy);
 
+    std::array<CBlockIndex, 12> blocks;
+    for (size_t i = 1; i < blocks.size(); ++i) {
+        blocks[i].pprev = &blocks[i - 1];
+    }
+    CBlockIndex *pindex = &blocks.back();
+    const int64_t MOCK_MTP{200000};
+    SetMTP(blocks, MOCK_MTP);
+
     CKey key;
     key.MakeNewKey(true);
     const CPubKey pubkey = key.GetPubKey();
@@ -351,65 +361,65 @@
     const auto runCheck = [&](const ProofValidationResult result,
                               const COutPoint &o, const Amount v,
                               const uint32_t h, const bool is_coinbase,
-                              const CKey &k) {
+                              const CKey &k, int64_t expirationTime) {
         // Generate a proof that match the UTXO.
-        ProofBuilder pb(0, 0, pubkey);
+        ProofBuilder pb(0, expirationTime, pubkey);
         pb.addUTXO(o, v, h, is_coinbase, k);
         Proof p = pb.build();
 
         ProofValidationState state;
         BOOST_CHECK(p.verify(state));
-        BOOST_CHECK(p.verify(state, coins) ==
+        BOOST_CHECK(p.verify(state, coins, pindex) ==
                     (result == ProofValidationResult::NONE));
         BOOST_CHECK(state.GetResult() == result);
     };
 
     // Valid proof
     runCheck(ProofValidationResult::NONE, pkh_outpoint, value, height, false,
-             key);
+             key, MOCK_MTP + 1);
 
     // Coinbase mismatch
     runCheck(ProofValidationResult::COINBASE_MISMATCH, pkh_outpoint, value,
-             height, true, key);
+             height, true, key, MOCK_MTP + 1);
 
     // Height mismatch
     runCheck(ProofValidationResult::HEIGHT_MISMATCH, pkh_outpoint, value,
-             height + 1, false, key);
+             height + 1, false, key, MOCK_MTP + 1);
 
     // Amount mismatch
     runCheck(ProofValidationResult::AMOUNT_MISMATCH, pkh_outpoint,
-             value + 1 * SATOSHI, height, false, key);
+             value + 1 * SATOSHI, height, false, key, MOCK_MTP + 1);
 
     // Invalid outpoints
     runCheck(ProofValidationResult::MISSING_UTXO,
              COutPoint(pkh_outpoint.GetTxId(), pkh_outpoint.GetN() + 1), value,
-             height, false, key);
+             height, false, key, MOCK_MTP + 1);
     runCheck(ProofValidationResult::MISSING_UTXO,
              COutPoint(TxId(InsecureRand256()), pkh_outpoint.GetN()), value,
-             height, false, key);
+             height, false, key, MOCK_MTP + 1);
 
     // Non standard script
     runCheck(ProofValidationResult::NON_STANDARD_DESTINATION, nonstd_outpoint,
-             value, height, false, key);
+             value, height, false, key, MOCK_MTP + 1);
 
     // Non PKHhash destination
     runCheck(ProofValidationResult::DESTINATION_NOT_SUPPORTED, p2sh_outpoint,
-             value, height, false, key);
+             value, height, false, key, MOCK_MTP + 1);
 
     // Mismatching key
     {
         CKey altkey;
         altkey.MakeNewKey(true);
         runCheck(ProofValidationResult::DESTINATION_MISMATCH, pkh_outpoint,
-                 value, height, false, altkey);
+                 value, height, false, altkey, MOCK_MTP + 1);
     }
 
     // No stake
     {
-        Proof p = ProofBuilder(0, 0, pubkey).build();
+        Proof p = ProofBuilder(0, MOCK_MTP + 1, pubkey).build();
 
         ProofValidationState state;
-        BOOST_CHECK(!p.verify(state, coins));
+        BOOST_CHECK(!p.verify(state, coins, pindex));
         BOOST_CHECK(state.GetResult() == ProofValidationResult::NO_STAKE);
     }
 
@@ -420,7 +430,7 @@
         Proof p = pb.build();
 
         ProofValidationState state;
-        BOOST_CHECK(!p.verify(state, coins));
+        BOOST_CHECK(!p.verify(state, coins, pindex));
         BOOST_CHECK(state.GetResult() == ProofValidationResult::DUST_THRESOLD);
     }
 
@@ -431,7 +441,7 @@
         Proof p = pb.build();
 
         ProofValidationState state;
-        BOOST_CHECK(!p.verify(state, coins));
+        BOOST_CHECK(!p.verify(state, coins, pindex));
         BOOST_CHECK(state.GetResult() == ProofValidationResult::DUST_THRESOLD);
     }
 
@@ -443,7 +453,7 @@
         Proof p = pb.build();
 
         ProofValidationState state;
-        BOOST_CHECK(!p.verify(state, coins));
+        BOOST_CHECK(!p.verify(state, coins, pindex));
         BOOST_CHECK(state.GetResult() ==
                     ProofValidationResult::DUPLICATE_STAKE);
     }
diff --git a/src/avalanche/validation.h b/src/avalanche/validation.h
--- a/src/avalanche/validation.h
+++ b/src/avalanche/validation.h
@@ -25,6 +25,8 @@
     NON_STANDARD_DESTINATION,
     DESTINATION_NOT_SUPPORTED,
     DESTINATION_MISMATCH,
+
+    EXPIRED,
 };
 
 class ProofValidationState : public ValidationState<ProofValidationResult> {};
diff --git a/src/rpc/avalanche.cpp b/src/rpc/avalanche.cpp
--- a/src/rpc/avalanche.cpp
+++ b/src/rpc/avalanche.cpp
@@ -479,8 +479,8 @@
     avalanche::ProofValidationState state;
     {
         LOCK(cs_main);
-        if (!proof.verify(state,
-                          node.chainman->ActiveChainstate().CoinsTip())) {
+        if (!proof.verify(state, node.chainman->ActiveChainstate().CoinsTip(),
+                          node.chainman->ActiveChain().Tip())) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "The proof is invalid: " + state.ToString());
         }
diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt
--- a/src/test/CMakeLists.txt
+++ b/src/test/CMakeLists.txt
@@ -45,6 +45,7 @@
 
 # An utility library for bitcoin related test suites.
 add_library(testutil OBJECT
+	util/block_utils.cpp
 	util/blockfilter.cpp
 	util/logging.cpp
 	util/mining.cpp
diff --git a/src/test/activation_tests.cpp b/src/test/activation_tests.cpp
--- a/src/test/activation_tests.cpp
+++ b/src/test/activation_tests.cpp
@@ -2,27 +2,17 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <chain.h>
 #include <chainparams.h>
 #include <consensus/activation.h>
 #include <util/system.h>
 
+#include <test/util/block_utils.h>
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 BOOST_FIXTURE_TEST_SUITE(activation_tests, BasicTestingSetup)
 
-static void SetMTP(std::array<CBlockIndex, 12> &blocks, int64_t mtp) {
-    size_t len = blocks.size();
-
-    for (size_t i = 0; i < len; ++i) {
-        blocks[i].nTime = mtp + (i - (len / 2));
-    }
-
-    BOOST_CHECK_EQUAL(blocks.back().GetMedianTimePast(), mtp);
-}
-
 static void testPastActivation(
     std::function<bool(const Consensus::Params &, const CBlockIndex *)> func,
     const Consensus::Params &params, int activationHeight) {
diff --git a/src/test/util/block_utils.h b/src/test/util/block_utils.h
new file mode 100644
--- /dev/null
+++ b/src/test/util/block_utils.h
@@ -0,0 +1,12 @@
+// Copyright (c) 2021 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_TEST_UTIL_BLOCK_UTILS_H
+#define BITCOIN_TEST_UTIL_BLOCK_UTILS_H
+
+#include <blockindex.h>
+
+void SetMTP(std::array<CBlockIndex, 12> &blocks, int64_t mtp);
+
+#endif // BITCOIN_TEST_UTIL_BLOCK_UTILS_H
diff --git a/src/test/util/block_utils.cpp b/src/test/util/block_utils.cpp
new file mode 100644
--- /dev/null
+++ b/src/test/util/block_utils.cpp
@@ -0,0 +1,17 @@
+// Copyright (c) 2021 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <test/util/block_utils.h>
+
+#include <boost/test/unit_test.hpp>
+
+void SetMTP(std::array<CBlockIndex, 12> &blocks, int64_t mtp) {
+    size_t len = blocks.size();
+
+    for (size_t i = 0; i < len; ++i) {
+        blocks[i].nTime = mtp + (i - (len / 2));
+    }
+
+    BOOST_CHECK_EQUAL(blocks.back().GetMedianTimePast(), mtp);
+}