diff --git a/src/avalanche/processor.h b/src/avalanche/processor.h
--- a/src/avalanche/processor.h
+++ b/src/avalanche/processor.h
@@ -315,6 +315,8 @@
      */
     bool isAvalancheServiceAvailable() { return !!peerData; }
 
+    bool addPeer(const Proof &proof);
+
     std::vector<avalanche::Peer> getPeers() const;
     std::vector<NodeId> getNodeIdsForPeer(PeerId peerId) const;
 
diff --git a/src/avalanche/processor.cpp b/src/avalanche/processor.cpp
--- a/src/avalanche/processor.cpp
+++ b/src/avalanche/processor.cpp
@@ -509,6 +509,11 @@
     return peerData->proof;
 }
 
+bool Processor::addPeer(const Proof &proof) {
+    LOCK(cs_peerManager);
+    return peerManager->getPeerId(proof) != NO_PEER;
+}
+
 bool Processor::startEventLoop(CScheduler &scheduler) {
     return eventLoop.startEventLoop(
         scheduler, [this]() { this->runEventLoop(); }, AVALANCHE_TIME_STEP);
diff --git a/src/avalanche/proof.cpp b/src/avalanche/proof.cpp
--- a/src/avalanche/proof.cpp
+++ b/src/avalanche/proof.cpp
@@ -9,6 +9,8 @@
 #include <hash.h>
 #include <script/standard.h>
 
+#include <tinyformat.h>
+
 #include <unordered_set>
 
 namespace avalanche {
@@ -49,26 +51,33 @@
 
 bool Proof::verify(ProofValidationState &state) const {
     if (stakes.empty()) {
-        return state.Invalid(ProofValidationResult::NO_STAKE);
+        return state.Invalid(ProofValidationResult::NO_STAKE, "no-stake");
     }
 
     if (stakes.size() > AVALANCHE_MAX_PROOF_STAKES) {
-        return state.Invalid(ProofValidationResult::TOO_MANY_UTXOS);
+        return state.Invalid(
+            ProofValidationResult::TOO_MANY_UTXOS, "too-many-utxos",
+            strprintf("%u > %u", stakes.size(), AVALANCHE_MAX_PROOF_STAKES));
     }
 
     std::unordered_set<COutPoint, SaltedOutpointHasher> utxos;
     for (const SignedStake &ss : stakes) {
         const Stake &s = ss.getStake();
         if (s.getAmount() < PROOF_DUST_THRESHOLD) {
-            return state.Invalid(ProofValidationResult::DUST_THRESOLD);
+            return state.Invalid(ProofValidationResult::DUST_THRESOLD,
+                                 "amount-below-dust-threshold",
+                                 strprintf("%s < %s", s.getAmount().ToString(),
+                                           PROOF_DUST_THRESHOLD.ToString()));
         }
 
         if (!utxos.insert(s.getUTXO()).second) {
-            return state.Invalid(ProofValidationResult::DUPLICATE_STAKE);
+            return state.Invalid(ProofValidationResult::DUPLICATE_STAKE,
+                                 "duplicated-stake");
         }
 
         if (!ss.verify(proofid)) {
-            return state.Invalid(ProofValidationResult::INVALID_SIGNATURE);
+            return state.Invalid(ProofValidationResult::INVALID_SIGNATURE,
+                                 "invalid-signature");
         }
     }
 
@@ -88,41 +97,55 @@
         Coin coin;
         if (!view.GetCoin(utxo, coin)) {
             // The coins are not in the UTXO set.
-            return state.Invalid(ProofValidationResult::MISSING_UTXO);
+            return state.Invalid(ProofValidationResult::MISSING_UTXO,
+                                 "utxo-missing-or-spent");
         }
 
         if (s.isCoinbase() != coin.IsCoinBase()) {
-            return state.Invalid(ProofValidationResult::COINBASE_MISMATCH);
+            return state.Invalid(
+                ProofValidationResult::COINBASE_MISMATCH, "coinbase-mismatch",
+                strprintf("expected %s, found %s",
+                          s.isCoinbase() ? "true" : "false",
+                          coin.IsCoinBase() ? "true" : "false"));
         }
 
         if (s.getHeight() != coin.GetHeight()) {
-            return state.Invalid(ProofValidationResult::HEIGHT_MISMATCH);
+            return state.Invalid(ProofValidationResult::HEIGHT_MISMATCH,
+                                 "height-mismatch",
+                                 strprintf("expected %u, found %u",
+                                           s.getHeight(), coin.GetHeight()));
         }
 
         const CTxOut &out = coin.GetTxOut();
         if (s.getAmount() != out.nValue) {
             // Wrong amount.
-            return state.Invalid(ProofValidationResult::AMOUNT_MISMATCH);
+            return state.Invalid(
+                ProofValidationResult::AMOUNT_MISMATCH, "amount-mismatch",
+                strprintf("expected %s, found %s", s.getAmount().ToString(),
+                          out.nValue.ToString()));
         }
 
         CTxDestination dest;
         if (!ExtractDestination(out.scriptPubKey, dest)) {
             // Can't extract destination.
             return state.Invalid(
-                ProofValidationResult::NON_STANDARD_DESTINATION);
+                ProofValidationResult::NON_STANDARD_DESTINATION,
+                "non-standard-destination");
         }
 
         PKHash *pkhash = boost::get<PKHash>(&dest);
         if (!pkhash) {
             // Only PKHash are supported.
             return state.Invalid(
-                ProofValidationResult::DESTINATION_NOT_SUPPORTED);
+                ProofValidationResult::DESTINATION_NOT_SUPPORTED,
+                "destination-type-not-supported");
         }
 
         const CPubKey &pubkey = s.getPubkey();
         if (*pkhash != PKHash(pubkey)) {
             // Wrong pubkey.
-            return state.Invalid(ProofValidationResult::DESTINATION_MISMATCH);
+            return state.Invalid(ProofValidationResult::DESTINATION_MISMATCH,
+                                 "destination-mismatch");
         }
     }
 
diff --git a/src/net_processing.h b/src/net_processing.h
--- a/src/net_processing.h
+++ b/src/net_processing.h
@@ -14,6 +14,9 @@
 extern RecursiveMutex cs_main;
 extern RecursiveMutex g_cs_orphans;
 
+namespace avalanche {
+struct ProofId;
+};
 class BlockTransactionsRequest;
 class BlockValidationState;
 class CBlockHeader;
@@ -215,4 +218,7 @@
 /** Relay transaction to every node */
 void RelayTransaction(const TxId &txid, const CConnman &connman);
 
+/** Relay proof to every node */
+void RelayProof(const avalanche::ProofId &proofid, const CConnman &connman);
+
 #endif // BITCOIN_NET_PROCESSING_H
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -1780,6 +1780,11 @@
         [&txid](CNode *pnode) { pnode->PushTxInventory(txid); });
 }
 
+void RelayProof(const avalanche::ProofId &proofid, const CConnman &connman) {
+    connman.ForEachNode(
+        [&proofid](CNode *pnode) { pnode->PushProofInventory(proofid); });
+}
+
 static void RelayAddress(const CAddress &addr, bool fReachable,
                          const CConnman &connman) {
     // Limited relaying of addresses outside our network(s)
diff --git a/src/rpc/avalanche.cpp b/src/rpc/avalanche.cpp
--- a/src/rpc/avalanche.cpp
+++ b/src/rpc/avalanche.cpp
@@ -12,6 +12,9 @@
 #include <config.h>
 #include <core_io.h>
 #include <key_io.h>
+#include <net_processing.h>
+#include <node/context.h>
+#include <rpc/blockchain.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <util/strencodings.h>
@@ -400,6 +403,51 @@
     return ret;
 }
 
+static UniValue sendavalancheproof(const Config &config,
+                                   const JSONRPCRequest &request) {
+    RPCHelpMan{
+        "sendavalancheproof",
+        "Broadcast an avalanche proof.\n",
+        {
+            {"proof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
+             "The avalanche proof to broadcast."},
+        },
+        RPCResult{RPCResult::Type::BOOL, "success",
+                  "Whether the proof was sent successfully or not."},
+        RPCExamples{HelpExampleRpc("sendavalancheproof", "<proof>")},
+    }
+        .Check(request);
+
+    if (!g_avalanche) {
+        throw JSONRPCError(RPC_INTERNAL_ERROR, "Avalanche is not initialized");
+    }
+
+    avalanche::Proof proof;
+    CDataStream ss(ParseHexV(request.params[0], "proof"), SER_NETWORK,
+                   PROTOCOL_VERSION);
+    ss >> proof;
+    const avalanche::ProofId &proofid = proof.getId();
+
+    NodeContext &node = EnsureNodeContext(request.context);
+
+    avalanche::ProofValidationState state;
+    {
+        LOCK(cs_main);
+        if (!proof.verify(state,
+                          node.chainman->ActiveChainstate().CoinsTip())) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER,
+                               "The proof is invalid: " + state.ToString());
+        }
+    }
+
+    if (g_avalanche->addPeer(proof)) {
+        RelayProof(proofid, *node.connman);
+        return true;
+    }
+
+    return false;
+}
+
 void RegisterAvalancheRPCCommands(CRPCTable &t) {
     // clang-format off
     static const CRPCCommand commands[] = {
@@ -410,6 +458,7 @@
         { "avalanche",          "buildavalancheproof",    buildavalancheproof,    {"sequence", "expiration", "master", "stakes"}},
         { "avalanche",          "delegateavalancheproof", delegateavalancheproof, {"proof", "privatekey", "publickey", "delegation"}},
         { "avalanche",          "getavalanchepeerinfo",   getavalanchepeerinfo,   {}},
+        { "avalanche",          "sendavalancheproof",     sendavalancheproof,     {"proof"}},
     };
     // clang-format on
 
diff --git a/test/functional/abc_p2p_proof_inventory.py b/test/functional/abc_p2p_proof_inventory.py
--- a/test/functional/abc_p2p_proof_inventory.py
+++ b/test/functional/abc_p2p_proof_inventory.py
@@ -14,6 +14,8 @@
 from test_framework.messages import (
     AvalancheProof,
     FromHex,
+    MSG_AVA_PROOF,
+    MSG_TYPE_MASK,
 )
 from test_framework.mininode import (
     P2PInterface,
@@ -26,6 +28,17 @@
 )
 
 
+class ProofInvStoreP2PInterface(P2PInterface):
+    def __init__(self):
+        super().__init__()
+        self.proof_invs = set()
+
+    def on_inv(self, message):
+        for i in message.inv:
+            if i.type & MSG_TYPE_MASK == MSG_AVA_PROOF:
+                self.proof_invs.add(i.hash)
+
+
 class ProofInventoryTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 1
@@ -89,6 +102,17 @@
 
         wait_until(lambda: all(proof_inv_found(i) for i in node.p2ps))
 
+        # Add more proofs to our pool
+        for i in range(10):
+            _, proof = self.gen_proof(node)
+            node.sendavalancheproof(proof.serialize().hex())
+            assert proof.proofid in get_proof_ids(node)
+
+        peer = ProofInvStoreP2PInterface()
+        node.add_p2p_connection(peer)
+
+        wait_until(lambda: set(get_proof_ids(node)) == peer.proof_invs)
+
     def run_test(self):
         self.test_send_proof_inv()
 
diff --git a/test/functional/abc_rpc_avalancheproof.py b/test/functional/abc_rpc_avalancheproof.py
--- a/test/functional/abc_rpc_avalancheproof.py
+++ b/test/functional/abc_rpc_avalancheproof.py
@@ -8,10 +8,15 @@
 from test_framework.avatools import (
     create_coinbase_stakes,
     create_stakes,
+    get_proof_ids,
 )
 from test_framework.key import ECKey, bytes_to_wif
-from test_framework.messages import AvalancheDelegation
-from test_framework.mininode import P2PInterface
+from test_framework.messages import (
+    AvalancheDelegation,
+    AvalancheProof,
+    FromHex,
+)
+from test_framework.mininode import P2PInterface, mininode_lock
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.test_node import ErrorMatch
 from test_framework.util import (
@@ -179,7 +184,6 @@
                                 )
 
         # Test invalid proofs
-        self.log.info("Bad proof should be rejected at startup")
         dust = node.buildavalancheproof(
             proof_sequence, proof_expiration, proof_master,
             create_coinbase_stakes(node, [blockhashes[0]], addrkey0.key, amount="0"))
@@ -202,6 +206,38 @@
                    "f7d2888d96b82962b3ce516d1083c0e031773487fc3c4f2e38acd1db974"
                    "1321b91a79b82d1c2cfd47793261e4ba003cf5")
 
+        self.log.info("Check the sendavalancheproof RPC")
+
+        # Restart to clear our proof pool
+        self.restart_node(0)
+
+        def check_sendavalancheproof_failure(proof, message):
+            assert_raises_rpc_error(-8, "The proof is invalid: " + message,
+                                    node.sendavalancheproof, proof)
+            assert FromHex(AvalancheProof(),
+                           proof).proofid not in get_proof_ids(node)
+
+        check_sendavalancheproof_failure(no_stake, "no-stake")
+        check_sendavalancheproof_failure(dust, "amount-below-dust-threshold")
+        check_sendavalancheproof_failure(duplicate_stake, "duplicated-stake")
+        check_sendavalancheproof_failure(bad_sig, "invalid-signature")
+        if self.is_wallet_compiled():
+            check_sendavalancheproof_failure(too_many_utxos, "too-many-utxos")
+
+        # Good proof
+        peer = node.add_p2p_connection(P2PInterface())
+        proofid = FromHex(AvalancheProof(), proof).proofid
+
+        node.sendavalancheproof(proof)
+        assert proofid in get_proof_ids(node)
+
+        def inv_found():
+            with mininode_lock:
+                return peer.last_message.get(
+                    "inv") and peer.last_message["inv"].inv[-1].hash == proofid
+        wait_until(inv_found)
+
+        self.log.info("Bad proof should be rejected at startup")
         self.stop_node(0)
 
         node.assert_start_raises_init_error(