diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index e64e59459..c57a67d3d 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,734 +1,735 @@
 # Copyright (c) 2017 The Bitcoin developers
 
 project(bitcoind)
 
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 # Default visibility is hidden on all targets.
 set(CMAKE_C_VISIBILITY_PRESET hidden)
 set(CMAKE_CXX_VISIBILITY_PRESET hidden)
 
 option(BUILD_BITCOIN_WALLET "Activate the wallet functionality" ON)
 option(BUILD_BITCOIN_ZMQ "Activate the ZeroMQ functionalities" ON)
 option(BUILD_BITCOIN_CLI "Build bitcoin-cli" ON)
 option(BUILD_BITCOIN_TX "Build bitcoin-tx" ON)
 option(BUILD_BITCOIN_QT "Build bitcoin-qt" ON)
 option(BUILD_BITCOIN_SEEDER "Build bitcoin-seeder" ON)
 option(BUILD_LIBBITCOINCONSENSUS "Build the bitcoinconsenus shared library" ON)
 option(ENABLE_BIP70 "Enable BIP70 (payment protocol) support in GUI" ON)
 option(ENABLE_HARDENING "Harden the executables" ON)
 option(ENABLE_REDUCE_EXPORTS "Reduce the amount of exported symbols" OFF)
 option(ENABLE_STATIC_LIBSTDCXX "Statically link libstdc++" OFF)
 option(ENABLE_GLIBC_BACK_COMPAT "Enable Glibc compatibility features" OFF)
 option(ENABLE_QRCODE "Enable QR code display" ON)
 option(ENABLE_UPNP "Enable UPnP support" ON)
 option(START_WITH_UPNP "Make UPnP the default to map ports" OFF)
 option(ENABLE_CLANG_TIDY "Enable clang-tidy checks for Bitcoin ABC" OFF)
 option(ENABLE_PROFILING "Select the profiling tool to use" OFF)
 
 # Linker option
 if(CMAKE_CROSSCOMPILING)
 	set(DEFAULT_LINKER "")
 elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
 	set(DEFAULT_LINKER lld)
 elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 	set(DEFAULT_LINKER gold)
 else()
 	set(DEFAULT_LINKER "")
 endif()
 set(USE_LINKER "${DEFAULT_LINKER}" CACHE STRING "Linker to be used (default: ${DEFAULT_LINKER}). Set to empty string to use the system's default.")
 
 set(OS_WITH_JEMALLOC_AS_SYSTEM_DEFAULT
 	"Android"
 	"FreeBSD"
 	"NetBSD"
 )
 if(NOT CMAKE_SYSTEM_NAME IN_LIST OS_WITH_JEMALLOC_AS_SYSTEM_DEFAULT)
 	set(USE_JEMALLOC_DEFAULT ON)
 endif()
 
 # FIXME: Building against jemalloc causes the software to segfault on OSX.
 # See https://github.com/Bitcoin-ABC/bitcoin-abc/issues/401
 if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin" AND NOT CMAKE_CROSSCOMPILING)
 	set(USE_JEMALLOC_DEFAULT OFF)
 endif()
 
 option(USE_JEMALLOC "Use jemalloc as an allocation library" ${USE_JEMALLOC_DEFAULT})
 
 if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
 	set(DEFAULT_ENABLE_DBUS_NOTIFICATIONS ON)
 endif()
 option(ENABLE_DBUS_NOTIFICATIONS "Enable DBus desktop notifications. Linux only." ${DEFAULT_ENABLE_DBUS_NOTIFICATIONS})
 
 # If ccache is available, then use it.
 find_program(CCACHE ccache)
 if(CCACHE)
 	message(STATUS "Using ccache: ${CCACHE}")
 	set(CMAKE_C_COMPILER_LAUNCHER ${CCACHE})
 	set(CMAKE_CXX_COMPILER_LAUNCHER ${CCACHE})
 endif(CCACHE)
 
 # Disable what we do not need for the native build.
 include(NativeExecutable)
 native_add_cmake_flags(
 	"-DBUILD_BITCOIN_WALLET=OFF"
 	"-DBUILD_BITCOIN_QT=OFF"
 	"-DBUILD_BITCOIN_ZMQ=OFF"
 	"-DENABLE_QRCODE=OFF"
 	"-DENABLE_UPNP=OFF"
 	"-DUSE_JEMALLOC=OFF"
 	"-DENABLE_CLANG_TIDY=OFF"
 	"-DENABLE_BIP70=OFF"
 )
 
 if(ENABLE_CLANG_TIDY)
 	include(ClangTidy)
 endif()
 
 if(ENABLE_SANITIZERS)
 	include(Sanitizers)
 	enable_sanitizers(${ENABLE_SANITIZERS})
 endif()
 
 include(AddCompilerFlags)
 
 if(USE_LINKER)
 	set(LINKER_FLAG "-fuse-ld=${USE_LINKER}")
 	check_linker_flag(IS_LINKER_SUPPORTED ${LINKER_FLAG})
 	if(NOT IS_LINKER_SUPPORTED)
 		message(FATAL_ERROR "The ${USE_LINKER} linker is not supported, make sure ${USE_LINKER} is properly installed or use -DUSE_LINKER= to use the system's linker")
 	endif()
 	add_linker_flags(${LINKER_FLAG})
 endif()
 
 # Prefer -g3, defaults to -g if unavailable
 foreach(LANGUAGE C CXX)
 	set(COMPILER_DEBUG_LEVEL -g)
 	check_compiler_flags(G3_IS_SUPPORTED ${LANGUAGE} -g3)
 	if(${G3_IS_SUPPORTED})
 		set(COMPILER_DEBUG_LEVEL -g3)
 	endif()
 	add_compile_options_to_configuration_for_language(Debug ${LANGUAGE} ${COMPILER_DEBUG_LEVEL})
 endforeach()
 
 # Define the debugging symbols DEBUG and DEBUG_LOCKORDER when the Debug build
 # type is selected.
 add_compile_definitions_to_configuration(Debug DEBUG DEBUG_LOCKORDER)
 
 # Add -ftrapv when building in Debug
 add_compile_options_to_configuration(Debug -ftrapv)
 
 # All versions of gcc that we commonly use for building are subject to bug
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90348. To work around that, set
 # -fstack-reuse=none for all gcc builds. (Only gcc understands this flag)
 if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
 	add_compiler_flags(-fstack-reuse=none)
 endif()
 
 if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
 	# Ensure that WINDRES_PREPROC is enabled when using windres.
 	list(APPEND CMAKE_RC_FLAGS "-DWINDRES_PREPROC")
 
 	# Build all static so there is no dll file to distribute.
 	add_linker_flags(-static)
 
 	add_compile_definitions(
 		# Windows 7
 		_WIN32_WINNT=0x0601
 		# Internet Explorer 5.01 (!)
 		_WIN32_IE=0x0501
 		# Define WIN32_LEAN_AND_MEAN to exclude APIs such as Cryptography, DDE,
 		# RPC, Shell, and Windows Sockets.
 		WIN32_LEAN_AND_MEAN
 	)
 endif()
 
 if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
 	add_compile_definitions(MAC_OSX OBJC_OLD_DISPATCH_PROTOTYPES=0)
 	add_linker_flags(-Wl,-dead_strip_dylibs)
 endif()
 
 if(ENABLE_REDUCE_EXPORTS)
 	# Default visibility is set by CMAKE_<LANG>_VISIBILITY_PRESET, but this
 	# doesn't tell if the visibility set is effective.
 	# Check if the flag -fvisibility=hidden is supported, as using the hidden
 	# visibility is a requirement to reduce exports.
 	check_compiler_flags(HAS_CXX_FVISIBILITY CXX -fvisibility=hidden)
 	if(NOT HAS_CXX_FVISIBILITY)
 		message(FATAL_ERROR "Cannot set default symbol visibility. Use -DENABLE_REDUCE_EXPORTS=OFF.")
 	endif()
 
 	# Also hide symbols from static libraries
 	add_linker_flags(-Wl,--exclude-libs,libstdc++)
 endif()
 
 # Enable statically linking libstdc++
 if(ENABLE_STATIC_LIBSTDCXX)
 	add_linker_flags(-static-libstdc++)
 endif()
 
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 
 if(ENABLE_HARDENING)
 	# Enable stack protection
 	add_cxx_compiler_flags(-fstack-protector-all -Wstack-protector)
 
 	# Enable some buffer overflow checking, except in -O0 builds which
 	# do not support them
 	add_compiler_flags(-U_FORTIFY_SOURCE)
 	add_compile_options($<$<NOT:$<CONFIG:Debug>>:-D_FORTIFY_SOURCE=2>)
 
 	# Enable ASLR (these flags are primarily targeting MinGw)
 	add_linker_flags(-Wl,--dynamicbase -Wl,--nxcompat -Wl,--high-entropy-va)
 
 	# Make the relocated sections read-only
 	add_linker_flags(-Wl,-z,relro -Wl,-z,now)
 
 	# CMake provides the POSITION_INDEPENDENT_CODE property to set PIC/PIE.
 	cmake_policy(SET CMP0083 NEW)
 	include(CheckPIESupported)
 	check_pie_supported()
 
 	if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
 		# MinGw provides its own libssp for stack smashing protection
 		link_libraries(ssp)
 	endif()
 endif()
 
 if(ENABLE_PROFILING MATCHES "gprof")
 	message(STATUS "Enable profiling with gprof")
 
 	# -pg is incompatible with -pie. Since hardening and profiling together
 	# doesn't make sense, we simply make them mutually exclusive here.
 	# Additionally, hardened toolchains may force -pie by default, in which
 	# case it needs to be turned off with -no-pie.
 	if(ENABLE_HARDENING)
 		message(FATAL_ERROR "Profiling with gprof requires disabling hardening with -DENABLE_HARDENING=OFF.")
 	endif()
 	add_linker_flags(-no-pie)
 
 	add_compiler_flags(-pg)
 	add_linker_flags(-pg)
 endif()
 
 # Enable warning
 add_c_compiler_flags(-Wnested-externs -Wstrict-prototypes)
 add_compiler_flags(
 	-Wall
 	-Wextra
 	-Wformat
 	-Wgnu
 	-Wvla
 	-Wcast-align
 	-Wunused-parameter
 	-Wmissing-braces
 	-Wthread-safety
 	-Wrange-loop-analysis
 	-Wredundant-decls
 	-Wunreachable-code-loop-increment
 	-Wsign-compare
 	-Wconditional-uninitialized
 )
 add_compiler_flag_group(-Wformat -Wformat-security)
 add_cxx_compiler_flags(
 	-Wredundant-move
 )
 
 if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
 	# GCC has no flag variant which is granular enough to avoid raising the clang
 	# -Wshadow-uncaptured-local equivalent. This is causing a lot of warnings
 	# on serialize.h which cannot be disabled locally, so drop the flag.
 	add_compiler_flags(
 		-Wshadow
 		-Wshadow-field
 	)
 endif()
 
 option(EXTRA_WARNINGS "Enable extra warnings" OFF)
 if(EXTRA_WARNINGS)
 	add_cxx_compiler_flags(-Wsuggest-override)
 else()
 	add_compiler_flags(-Wno-unused-parameter)
 	add_compiler_flags(-Wno-implicit-fallthrough)
 endif()
 
 # libtool style configure
 add_subdirectory(config)
 
 # Enable LFS (Large File Support) on targets that don't have it natively.
 # This should be defined before the libraries are included as leveldb need the
 # definition to be set.
 if(NOT HAVE_LARGE_FILE_SUPPORT)
 	add_compile_definitions(_FILE_OFFSET_BITS=64)
 	add_linker_flags(-Wl,--large-address-aware)
 endif()
 
 if(ENABLE_GLIBC_BACK_COMPAT)
 	# Wrap some glibc functions with ours
 	add_linker_flags(-Wl,--wrap=__divmoddi4)
 	add_linker_flags(-Wl,--wrap=log2f)
 
 	if(NOT HAVE_LARGE_FILE_SUPPORT)
 		add_linker_flags(-Wl,--wrap=fcntl -Wl,--wrap=fcntl64)
 	endif()
 endif()
 
 if(USE_JEMALLOC)
 	# Most of the sanitizers require their instrumented allocation functions to
 	# be fully functional. This is obviously the case for all the memory related
 	# sanitizers (asan, lsan, msan) but not only.
 	if(ENABLE_SANITIZERS)
 		message(WARNING "Jemalloc is incompatible with the sanitizers and has been disabled.")
 	else()
 		find_package(Jemalloc 3.6.0 REQUIRED)
 		link_libraries(Jemalloc::jemalloc)
 	endif()
 endif()
 
 
 # Make sure that all the global compiler and linker flags are set BEFORE
 # including the libraries so they apply as needed.
 
 
 # libraries
 add_subdirectory(crypto)
 add_subdirectory(leveldb)
 add_subdirectory(secp256k1)
 add_subdirectory(univalue)
 
 # Find the git root, and returns the full path to the .git/logs/HEAD file if
 # it exists.
 function(find_git_head_logs_file RESULT)
 	find_package(Git)
 	if(GIT_FOUND)
 		execute_process(
 			COMMAND "${GIT_EXECUTABLE}" "rev-parse" "--show-toplevel"
 			WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
 			OUTPUT_VARIABLE GIT_ROOT
 			RESULT_VARIABLE GIT_RESULT
 			OUTPUT_STRIP_TRAILING_WHITESPACE
 			ERROR_QUIET
 		)
 
 		if(GIT_RESULT EQUAL 0)
 			set(GIT_LOGS_DIR "${GIT_ROOT}/.git/logs")
 			set(GIT_HEAD_LOGS_FILE "${GIT_LOGS_DIR}/HEAD")
 			# If the .git/logs/HEAD does not exist, create it
 			if(NOT EXISTS "${GIT_HEAD_LOGS_FILE}")
 				file(MAKE_DIRECTORY "${GIT_LOGS_DIR}")
 				file(TOUCH "${GIT_HEAD_LOGS_FILE}")
 			endif()
 			set(${RESULT} "${GIT_HEAD_LOGS_FILE}" PARENT_SCOPE)
 		endif()
 	endif()
 endfunction()
 
 find_git_head_logs_file(GIT_HEAD_LOGS_FILE)
 
 set(OBJ_DIR "${CMAKE_CURRENT_BINARY_DIR}/obj")
 file(MAKE_DIRECTORY "${OBJ_DIR}")
 set(BUILD_HEADER "${OBJ_DIR}/build.h")
 set(BUILD_HEADER_TMP "${BUILD_HEADER}.tmp")
 
 add_custom_command(
 	DEPENDS
 		"${GIT_HEAD_LOGS_FILE}"
 		"${CMAKE_SOURCE_DIR}/share/genbuild.sh"
 	OUTPUT
 		"${BUILD_HEADER}"
 	COMMAND
 		"${CMAKE_SOURCE_DIR}/share/genbuild.sh"
 		"${BUILD_HEADER_TMP}"
 		"${CMAKE_SOURCE_DIR}"
 	COMMAND
 		${CMAKE_COMMAND} -E copy_if_different "${BUILD_HEADER_TMP}" "${BUILD_HEADER}"
 	COMMAND
 		${CMAKE_COMMAND} -E remove "${BUILD_HEADER_TMP}"
 )
 
 # Because the Bitcoin ABc source code is disorganised, we
 # end up with a bunch of libraries without any apparent
 # cohesive structure. This is inherited from Bitcoin Core
 # and reflecting this.
 # TODO: Improve the structure once cmake is rocking.
 
 # Various completely unrelated features shared by all executables.
 add_library(util
 	chainparamsbase.cpp
 	clientversion.cpp
 	compat/glibcxx_sanity.cpp
 	compat/strnlen.cpp
 	fs.cpp
 	interfaces/handler.cpp
 	logging.cpp
 	random.cpp
 	randomenv.cpp
 	rcu.cpp
 	rpc/request.cpp
 	blockdb.cpp
 	support/cleanse.cpp
 	support/lockedpool.cpp
 	sync.cpp
 	threadinterrupt.cpp
 	uint256.cpp
 	util/asmap.cpp
 	util/bip32.cpp
 	util/bytevectorhash.cpp
 	util/error.cpp
 	util/message.cpp
 	util/moneystr.cpp
 	util/settings.cpp
 	util/spanparsing.cpp
 	util/strencodings.cpp
 	util/string.cpp
 	util/system.cpp
 	util/threadnames.cpp
 	util/time.cpp
 	util/url.cpp
 
 	# obj/build.h
 	"${BUILD_HEADER}"
 )
 
 target_compile_definitions(util PUBLIC HAVE_CONFIG_H HAVE_BUILD_INFO)
 target_include_directories(util
 	PUBLIC
 		.
 		# To access the config/ and obj/ directories
 		${CMAKE_CURRENT_BINARY_DIR}
 )
 
 if(ENABLE_GLIBC_BACK_COMPAT)
 	target_sources(util PRIVATE compat/glibc_compat.cpp)
 endif()
 
 # Target specific configs
 if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
 	set(Boost_USE_STATIC_LIBS ON)
 	set(Boost_USE_STATIC_RUNTIME ON)
 	set(Boost_THREADAPI win32)
 
 	find_package(SHLWAPI REQUIRED)
 	target_link_libraries(util SHLWAPI::shlwapi)
 
 	find_library(WS2_32_LIBRARY NAMES ws2_32)
 	target_link_libraries(util ${WS2_32_LIBRARY})
 
 	target_compile_definitions(util PUBLIC BOOST_THREAD_USE_LIB)
 endif()
 
 target_link_libraries(util univalue crypto)
 
 macro(link_event TARGET)
 	non_native_target_link_libraries(${TARGET} Event 2.0.22 ${ARGN})
 endmacro()
 
 link_event(util event)
 
 macro(link_boost TARGET)
 	non_native_target_link_libraries(${TARGET} Boost 1.59 ${ARGN})
 endmacro()
 
 link_boost(util filesystem thread)
 # Make sure boost uses std::atomic (it doesn't before 1.63)
 target_compile_definitions(util PUBLIC BOOST_SP_USE_STD_ATOMIC BOOST_AC_USE_STD_ATOMIC)
 
 function(add_network_sources NETWORK_SOURCES)
 	set(NETWORK_DIR abc)
 
 	list(TRANSFORM
 		ARGN
 		PREPEND "networks/${NETWORK_DIR}/"
 		OUTPUT_VARIABLE NETWORK_SOURCES
 	)
 	set(NETWORK_SOURCES ${NETWORK_SOURCES} PARENT_SCOPE)
 endfunction()
 
 add_network_sources(NETWORK_SOURCES
 	checkpoints.cpp
 	network.cpp
 	chainparamsconstants.cpp
 )
 
 # More completely unrelated features shared by all executables.
 # Because nothing says this is different from util than "common"
 add_library(common
 	amount.cpp
 	base58.cpp
 	bloom.cpp
 	cashaddr.cpp
 	cashaddrenc.cpp
 	chainparams.cpp
 	config.cpp
 	consensus/merkle.cpp
 	coins.cpp
 	compressor.cpp
 	eventloop.cpp
 	feerate.cpp
 	core_read.cpp
 	core_write.cpp
 	key.cpp
 	key_io.cpp
 	merkleblock.cpp
 	net_permissions.cpp
 	netaddress.cpp
 	netbase.cpp
 	outputtype.cpp
 	policy/policy.cpp
 	primitives/block.cpp
 	protocol.cpp
 	psbt.cpp
 	rpc/rawtransaction_util.cpp
 	rpc/util.cpp
 	scheduler.cpp
 	salteduint256hasher.cpp
 	versionbitsinfo.cpp
 	warnings.cpp
 
 	${NETWORK_SOURCES}
 )
 
 target_link_libraries(common bitcoinconsensus util secp256k1 script)
 
 # script library
 add_library(script
 	script/bitfield.cpp
 	script/descriptor.cpp
 	script/interpreter.cpp
 	script/script.cpp
 	script/script_error.cpp
 	script/sigencoding.cpp
 	script/sign.cpp
 	script/signingprovider.cpp
 	script/standard.cpp
 )
 
 target_link_libraries(script common)
 
 # libbitcoinconsensus
 add_library(bitcoinconsensus
 	arith_uint256.cpp
 	hash.cpp
 	primitives/transaction.cpp
 	pubkey.cpp
 	uint256.cpp
 	util/strencodings.cpp
 	consensus/tx_check.cpp
 )
 
 target_link_libraries(bitcoinconsensus script)
 
 include(InstallationHelper)
 if(BUILD_LIBBITCOINCONSENSUS)
 	target_compile_definitions(bitcoinconsensus
 		PUBLIC
 			BUILD_BITCOIN_INTERNAL
 			HAVE_CONSENSUS_LIB
 	)
 
 	install_shared_library(bitcoinconsensus
 		script/bitcoinconsensus.cpp
 		PUBLIC_HEADER script/bitcoinconsensus.h
 	)
 endif()
 
 # Bitcoin server facilities
 add_library(server
 	addrdb.cpp
 	addrman.cpp
 	avalanche/delegation.cpp
 	avalanche/delegationbuilder.cpp
+	avalanche/orphanproofpool.cpp
 	avalanche/peermanager.cpp
 	avalanche/processor.cpp
 	avalanche/proof.cpp
 	avalanche/proofbuilder.cpp
 	banman.cpp
 	blockencodings.cpp
 	blockfilter.cpp
 	blockindex.cpp
 	chain.cpp
 	checkpoints.cpp
 	config.cpp
 	consensus/activation.cpp
 	consensus/tx_verify.cpp
 	dbwrapper.cpp
 	dnsseeds.cpp
 	flatfile.cpp
 	httprpc.cpp
 	httpserver.cpp
 	index/base.cpp
 	index/blockfilterindex.cpp
 	index/txindex.cpp
 	init.cpp
 	interfaces/chain.cpp
 	interfaces/node.cpp
 	miner.cpp
 	minerfund.cpp
 	net.cpp
 	net_processing.cpp
 	node/coin.cpp
 	node/coinstats.cpp
 	node/context.cpp
 	node/psbt.cpp
 	node/transaction.cpp
 	node/ui_interface.cpp
 	noui.cpp
 	policy/fees.cpp
 	policy/settings.cpp
 	pow/aserti32d.cpp
 	pow/daa.cpp
 	pow/eda.cpp
 	pow/grasberg.cpp
 	pow/pow.cpp
 	rest.cpp
 	rpc/abc.cpp
 	rpc/avalanche.cpp
 	rpc/blockchain.cpp
 	rpc/command.cpp
 	rpc/mining.cpp
 	rpc/misc.cpp
 	rpc/net.cpp
 	rpc/rawtransaction.cpp
 	rpc/server.cpp
 	script/scriptcache.cpp
 	script/sigcache.cpp
 	shutdown.cpp
 	timedata.cpp
 	torcontrol.cpp
 	txdb.cpp
 	txmempool.cpp
 	validation.cpp
 	validationinterface.cpp
 	versionbits.cpp
 )
 
 target_include_directories(server PRIVATE leveldb/helpers/memenv)
 
 target_link_libraries(server
 	bitcoinconsensus
 	leveldb
 	memenv
 )
 
 link_event(server event)
 if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Windows")
 	link_event(server pthreads)
 endif()
 
 if(ENABLE_UPNP)
 	find_package(MiniUPnPc 1.9 REQUIRED)
 	target_link_libraries(server MiniUPnPc::miniupnpc)
 
 	if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
 		# TODO: check if we are really using a static library. Assume this is
 		# the one from the depends for now since the native windows build is not
 		# supported.
 		target_compile_definitions(server
 			PUBLIC -DSTATICLIB
 			PUBLIC -DMINIUPNP_STATICLIB
 		)
 	endif()
 endif()
 
 # Test suites.
 add_subdirectory(test)
 add_subdirectory(avalanche/test)
 add_subdirectory(pow/test)
 
 # Benchmark suite.
 add_subdirectory(bench)
 
 include(BinaryTest)
 include(WindowsVersionInfo)
 
 # Wallet
 if(BUILD_BITCOIN_WALLET)
 	add_subdirectory(wallet)
 	target_link_libraries(server wallet)
 
 	# bitcoin-wallet
 	add_executable(bitcoin-wallet bitcoin-wallet.cpp)
 	generate_windows_version_info(bitcoin-wallet
 		DESCRIPTION "CLI tool for ${PACKAGE_NAME} wallets"
 	)
 
 	target_link_libraries(bitcoin-wallet wallet-tool common util)
 
 	add_to_symbols_check(bitcoin-wallet)
 	add_to_security_check(bitcoin-wallet)
 
 	install_target(bitcoin-wallet)
 	install_manpages(bitcoin-wallet)
 else()
 	target_sources(server PRIVATE dummywallet.cpp)
 endif()
 
 # ZeroMQ
 if(BUILD_BITCOIN_ZMQ)
 	add_subdirectory(zmq)
 	target_link_libraries(server zmq)
 endif()
 
 # RPC client support
 add_library(rpcclient
 	compat/stdin.cpp
 	rpc/client.cpp
 )
 
 target_link_libraries(rpcclient univalue util)
 
 # bitcoin-seeder
 if(BUILD_BITCOIN_SEEDER)
 	add_subdirectory(seeder)
 endif()
 
 # bitcoin-cli
 if(BUILD_BITCOIN_CLI)
 	add_executable(bitcoin-cli bitcoin-cli.cpp)
 	generate_windows_version_info(bitcoin-cli
 		DESCRIPTION "JSON-RPC client for ${PACKAGE_NAME}"
 	)
 
 	target_link_libraries(bitcoin-cli common rpcclient)
 	link_event(bitcoin-cli event)
 
 	add_to_symbols_check(bitcoin-cli)
 	add_to_security_check(bitcoin-cli)
 
 	install_target(bitcoin-cli)
 	install_manpages(bitcoin-cli)
 endif()
 
 # bitcoin-tx
 if(BUILD_BITCOIN_TX)
 	add_executable(bitcoin-tx bitcoin-tx.cpp)
 	generate_windows_version_info(bitcoin-tx
 		DESCRIPTION "CLI Bitcoin transaction editor utility"
 	)
 
 	target_link_libraries(bitcoin-tx bitcoinconsensus)
 
 	add_to_symbols_check(bitcoin-tx)
 	add_to_security_check(bitcoin-tx)
 
 	install_target(bitcoin-tx)
 	install_manpages(bitcoin-tx)
 endif()
 
 # bitcoind
 add_executable(bitcoind bitcoind.cpp)
 target_link_libraries(bitcoind server)
 generate_windows_version_info(bitcoind
 	DESCRIPTION "Bitcoin node with a JSON-RPC server"
 )
 add_to_symbols_check(bitcoind)
 add_to_security_check(bitcoind)
 
 install_target(bitcoind)
 install_manpages(bitcoind)
 
 # Bitcoin-qt
 if(BUILD_BITCOIN_QT)
 	add_subdirectory(qt)
 endif()
diff --git a/src/avalanche/orphanproofpool.cpp b/src/avalanche/orphanproofpool.cpp
new file mode 100644
index 000000000..96f6acff3
--- /dev/null
+++ b/src/avalanche/orphanproofpool.cpp
@@ -0,0 +1,53 @@
+// 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 <avalanche/orphanproofpool.h>
+
+namespace avalanche {
+
+void OrphanProofPool::trimToMaximumSize() {
+    auto &proofs_by_sequence = proofs.get<by_sequence>();
+    auto it = proofs_by_sequence.begin();
+    while (nStakes > maxNumberOfStakes) {
+        nStakes -= it->getStakes().size();
+        it = proofs_by_sequence.erase(it);
+    }
+}
+
+bool OrphanProofPool::addProof(Proof proof) {
+    size_t nStakesProof = proof.getStakes().size();
+    if (!proofs.push_back(std::move(proof)).second) {
+        return false;
+    }
+    nStakes += nStakesProof;
+    trimToMaximumSize();
+    return true;
+}
+
+bool OrphanProofPool::removeProof(const ProofId &proofId) {
+    auto &proofs_by_id = proofs.get<by_proofid>();
+    auto it = proofs_by_id.find(proofId);
+    if (it == proofs_by_id.end()) {
+        return false;
+    }
+    nStakes -= it->getStakes().size();
+    proofs_by_id.erase(it);
+    return true;
+}
+
+const Proof *OrphanProofPool::getProof(const ProofId &proofId) const {
+    auto &proofs_by_proofid = proofs.get<by_proofid>();
+    auto it = proofs_by_proofid.find(proofId);
+    return it == proofs_by_proofid.end() ? nullptr : &*it;
+}
+
+size_t OrphanProofPool::getNProofs() const {
+    return proofs.size();
+}
+
+size_t OrphanProofPool::getNStakes() const {
+    return nStakes;
+}
+
+} // namespace avalanche
diff --git a/src/avalanche/orphanproofpool.h b/src/avalanche/orphanproofpool.h
new file mode 100644
index 000000000..f6cbef852
--- /dev/null
+++ b/src/avalanche/orphanproofpool.h
@@ -0,0 +1,78 @@
+// 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_AVALANCHE_ORPHANPROOFPOOL_H
+#define BITCOIN_AVALANCHE_ORPHANPROOFPOOL_H
+
+#include <avalanche/proof.h>
+
+#include <boost/multi_index/hashed_index.hpp>
+#include <boost/multi_index/sequenced_index.hpp>
+#include <boost/multi_index_container.hpp>
+
+namespace avalanche {
+
+// Extracts a ProofId from a Proof
+struct proofid_extractor {
+    using result_type = ProofId;
+    result_type operator()(const Proof &proof) const { return proof.getId(); }
+};
+
+struct by_sequence {};
+struct by_proofid {};
+
+using ProofContainer = boost::multi_index_container<
+    Proof,
+    boost::multi_index::indexed_by<
+        // keep insertion order
+        boost::multi_index::sequenced<boost::multi_index::tag<by_sequence>>,
+        // indexed by proofid
+        boost::multi_index::hashed_unique<boost::multi_index::tag<by_proofid>,
+                                          proofid_extractor,
+                                          SaltedProofIdHasher>>>;
+
+/**
+ * OrphanProofPool stores orphan proofs waiting for their UTXOs to be
+ * discovered.
+ * The pool has a size limit. When the pool is full, the oldest proof is
+ * removed when a new one is added.
+ */
+class OrphanProofPool {
+    ProofContainer proofs;
+
+    const size_t maxNumberOfStakes;
+    size_t nStakes = 0;
+
+    /**
+     *  Trim the proof pool to given max size.
+     *  It the current size is <= max size this has no effect.
+     */
+    void trimToMaximumSize();
+
+public:
+    OrphanProofPool(size_t maxNumberOfStakes)
+        : maxNumberOfStakes(maxNumberOfStakes) {}
+
+    /**
+     * Add a proof to the pool.
+     * The caller is responsible for checking the proof.
+     */
+    bool addProof(Proof proof);
+
+    /** Remove a proof from the pool. */
+    bool removeProof(const ProofId &proofId);
+
+    /**
+     * Get a pointer to a proof by id, or nullptr if the proof is not in the
+     * pool.
+     */
+    const Proof *getProof(const ProofId &proofId) const;
+
+    // For testing
+    size_t getNProofs() const;
+    size_t getNStakes() const;
+};
+
+} // namespace avalanche
+
+#endif // BITCOIN_AVALANCHE_ORPHANPROOFPOOL_H
diff --git a/src/avalanche/peermanager.h b/src/avalanche/peermanager.h
index 5e9caa742..58ffe7fda 100644
--- a/src/avalanche/peermanager.h
+++ b/src/avalanche/peermanager.h
@@ -1,205 +1,198 @@
 // Copyright (c) 2020 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_AVALANCHE_PEERMANAGER_H
 #define BITCOIN_AVALANCHE_PEERMANAGER_H
 
 #include <avalanche/node.h>
 #include <avalanche/proof.h>
 #include <coins.h>
 #include <net.h>
 #include <pubkey.h>
 #include <salteduint256hasher.h>
 
 #include <boost/multi_index/composite_key.hpp>
 #include <boost/multi_index/hashed_index.hpp>
 #include <boost/multi_index/member.hpp>
 #include <boost/multi_index/ordered_index.hpp>
 #include <boost/multi_index_container.hpp>
 
 #include <chrono>
 #include <cstdint>
 #include <vector>
 
 namespace avalanche {
 
 class Delegation;
 
 struct Slot {
 private:
     uint64_t start;
     uint32_t score;
     PeerId peerid;
 
 public:
     Slot(uint64_t startIn, uint32_t scoreIn, PeerId peeridIn)
         : start(startIn), score(scoreIn), peerid(peeridIn) {}
 
     Slot withStart(uint64_t startIn) const {
         return Slot(startIn, score, peerid);
     }
     Slot withScore(uint64_t scoreIn) const {
         return Slot(start, scoreIn, peerid);
     }
     Slot withPeerId(PeerId peeridIn) const {
         return Slot(start, score, peeridIn);
     }
 
     uint64_t getStart() const { return start; }
     uint64_t getStop() const { return start + score; }
     uint32_t getScore() const { return score; }
     PeerId getPeerId() const { return peerid; }
 
     bool contains(uint64_t slot) const {
         return getStart() <= slot && slot < getStop();
     }
     bool precedes(uint64_t slot) const { return slot >= getStop(); }
     bool follows(uint64_t slot) const { return getStart() > slot; }
 };
 
 struct Peer {
     PeerId peerid;
     uint32_t index = -1;
     uint32_t node_count = 0;
 
     Proof proof;
 
     Peer(PeerId peerid_, Proof proof_)
         : peerid(peerid_), proof(std::move(proof_)) {}
 
     const ProofId &getProofId() const { return proof.getId(); }
     uint32_t getScore() const { return proof.getScore(); }
 };
 
 struct proof_index {
     using result_type = ProofId;
     result_type operator()(const Peer &p) const { return p.proof.getId(); }
 };
 
-class SaltedProofIdHasher : private SaltedUint256Hasher {
-public:
-    SaltedProofIdHasher() : SaltedUint256Hasher() {}
-
-    size_t operator()(const ProofId &proofid) const { return hash(proofid); }
-};
-
 struct next_request_time {};
 
 class PeerManager {
     std::vector<Slot> slots;
     uint64_t slotCount = 0;
     uint64_t fragmentation = 0;
 
     /**
      * Several nodes can make an avalanche peer. In this case, all nodes are
      * considered interchangeable parts of the same peer.
      */
     using PeerSet = boost::multi_index_container<
         Peer, boost::multi_index::indexed_by<
                   // index by peerid
                   boost::multi_index::hashed_unique<
                       boost::multi_index::member<Peer, PeerId, &Peer::peerid>>,
                   // index by proof
                   boost::multi_index::hashed_unique<
                       boost::multi_index::tag<proof_index>, proof_index,
                       SaltedProofIdHasher>>>;
 
     PeerId nextPeerId = 0;
     PeerSet peers;
 
     std::unordered_map<COutPoint, PeerId, SaltedOutpointHasher> utxos;
 
     using NodeSet = boost::multi_index_container<
         Node,
         boost::multi_index::indexed_by<
             // index by nodeid
             boost::multi_index::hashed_unique<
                 boost::multi_index::member<Node, NodeId, &Node::nodeid>>,
             // sorted by peerid/nextRequestTime
             boost::multi_index::ordered_non_unique<
                 boost::multi_index::tag<next_request_time>,
                 boost::multi_index::composite_key<
                     Node,
                     boost::multi_index::member<Node, PeerId, &Node::peerid>,
                     boost::multi_index::member<Node, TimePoint,
                                                &Node::nextRequestTime>>>>>;
 
     NodeSet nodes;
 
     static constexpr int SELECT_PEER_MAX_RETRY = 3;
     static constexpr int SELECT_NODE_MAX_RETRY = 3;
 
 public:
     /**
      * Node API.
      */
     bool addNode(NodeId nodeid, const Proof &proof,
                  const Delegation &delegation);
     bool removeNode(NodeId nodeid);
 
     bool forNode(NodeId nodeid, std::function<bool(const Node &n)> func) const;
     bool updateNextRequestTime(NodeId nodeid, TimePoint timeout);
 
     /**
      * Randomly select a node to poll.
      */
     NodeId selectNode();
 
     /**
      * Update the peer set when a nw block is connected.
      */
     void updatedBlockTip();
 
     /****************************************************
      * Functions which are public for testing purposes. *
      ****************************************************/
     /**
      * Provide the PeerId associated with the given proof. If the peer does not
      * exists, then it is created.
      */
     PeerId getPeerId(const Proof &proof);
 
     /**
      * Remove an existing peer.
      */
     bool removePeer(const PeerId peerid);
 
     /**
      * Randomly select a peer to poll.
      */
     PeerId selectPeer() const;
 
     /**
      * Trigger maintenance of internal datastructures.
      * Returns how much slot space was saved after compaction.
      */
     uint64_t compact();
 
     /**
      * Perform consistency check on internal data structures.
      */
     bool verify() const;
 
     // Accssors.
     uint64_t getSlotCount() const { return slotCount; }
     uint64_t getFragmentation() const { return fragmentation; }
 
     std::vector<Peer> getPeers() const;
     std::vector<NodeId> getNodeIdsForPeer(PeerId peerId) const;
 
 private:
     PeerSet::iterator fetchOrCreatePeer(const Proof &proof);
     bool addNodeToPeer(const PeerSet::iterator &it);
     bool removeNodeFromPeer(const PeerSet::iterator &it, uint32_t count = 1);
 };
 
 /**
  * This is an internal method that is exposed for testing purposes.
  */
 PeerId selectPeerImpl(const std::vector<Slot> &slots, const uint64_t slot,
                       const uint64_t max);
 
 } // namespace avalanche
 
 #endif // BITCOIN_AVALANCHE_PEERMANAGER_H
diff --git a/src/avalanche/proofid.h b/src/avalanche/proofid.h
index b6345803a..c1aa02651 100644
--- a/src/avalanche/proofid.h
+++ b/src/avalanche/proofid.h
@@ -1,26 +1,34 @@
 // Copyright (c) 2020 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_AVALANCHE_PROOFID_H
 #define BITCOIN_AVALANCHE_PROOFID_H
 
+#include <salteduint256hasher.h>
 #include <uint256.h>
 
 #include <string>
 
 namespace avalanche {
 
 struct ProofId : public uint256 {
     explicit ProofId() : uint256() {}
     explicit ProofId(const uint256 &b) : uint256(b) {}
 
     static ProofId fromHex(const std::string &str) {
         ProofId r;
         r.SetHex(str);
         return r;
     }
 };
+
+class SaltedProofIdHasher : private SaltedUint256Hasher {
+public:
+    SaltedProofIdHasher() : SaltedUint256Hasher() {}
+    size_t operator()(const ProofId &proofid) const { return hash(proofid); }
+};
+
 } // namespace avalanche
 
 #endif // BITCOIN_AVALANCHE_PROOFID_H
diff --git a/src/avalanche/test/CMakeLists.txt b/src/avalanche/test/CMakeLists.txt
index 4b59dd046..dde93ee7c 100644
--- a/src/avalanche/test/CMakeLists.txt
+++ b/src/avalanche/test/CMakeLists.txt
@@ -1,22 +1,23 @@
 # Copyright (c) 2020 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 project(avalanche-test)
 
 include(TestSuite)
 create_test_suite(avalanche)
 add_dependencies(check check-avalanche)
 
 add_boost_unit_tests_to_suite(avalanche test-avalanche
 	fixture.cpp
 	util.cpp
 
 	TESTS
 		delegation_tests.cpp
+		orphanproofpool_tests.cpp
 		peermanager_tests.cpp
 		processor_tests.cpp
 		proof_tests.cpp
 )
 
 target_link_libraries(test-avalanche server testutil)
diff --git a/src/avalanche/test/orphanproofpool_tests.cpp b/src/avalanche/test/orphanproofpool_tests.cpp
new file mode 100644
index 000000000..4eb4dc881
--- /dev/null
+++ b/src/avalanche/test/orphanproofpool_tests.cpp
@@ -0,0 +1,164 @@
+// 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 <avalanche/orphanproofpool.h>
+#include <avalanche/proofbuilder.h>
+
+#include <validation.h>
+
+#include <test/util/setup_common.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <array>
+#include <queue>
+
+using namespace avalanche;
+
+BOOST_FIXTURE_TEST_SUITE(orphanproofpool_tests, TestingSetup)
+
+/** Make a proof with stakes using random txids */
+static Proof makeProof(const size_t nStakes) {
+    const Amount v = 5 * COIN;
+    const int height = 1234;
+    CKey key;
+    key.MakeNewKey(true);
+    ProofBuilder pb(0, 0, CPubKey());
+    for (size_t i = 0; i < nStakes; i++) {
+        TxId txid(GetRandHash());
+        pb.addUTXO(COutPoint(txid, 0), v, height, false, key);
+    }
+    return pb.build();
+}
+
+BOOST_AUTO_TEST_CASE(pool_starts_empty) {
+    OrphanProofPool pool{10};
+    BOOST_CHECK_EQUAL(pool.getNProofs(), 0);
+    BOOST_CHECK_EQUAL(pool.getNStakes(), 0);
+}
+
+BOOST_AUTO_TEST_CASE(fail_to_add_same_proof_twice) {
+    OrphanProofPool pool{10};
+    Proof p = makeProof(1);
+    BOOST_CHECK(!pool.getProof(p.getId()));
+
+    BOOST_CHECK(pool.addProof(p));
+    BOOST_CHECK_EQUAL(pool.getNStakes(), 1);
+    BOOST_CHECK_EQUAL(pool.getNProofs(), 1);
+    BOOST_CHECK(pool.getProof(p.getId()));
+
+    BOOST_CHECK(!pool.addProof(p));
+    BOOST_CHECK_EQUAL(pool.getNStakes(), 1);
+    BOOST_CHECK_EQUAL(pool.getNProofs(), 1);
+    BOOST_CHECK(pool.getProof(p.getId()));
+}
+
+BOOST_AUTO_TEST_CASE(check_eviction_behavior) {
+    {
+        // Fill the pool
+        OrphanProofPool pool{7};
+        Proof first = makeProof(4);
+        pool.addProof(first);
+        pool.addProof(makeProof(2));
+        pool.addProof(makeProof(1));
+        BOOST_CHECK_EQUAL(pool.getNStakes(), 7);
+        BOOST_CHECK_EQUAL(pool.getNProofs(), 3);
+        BOOST_CHECK(pool.getProof(first.getId()));
+    }
+
+    {
+        OrphanProofPool pool{6};
+        Proof first = makeProof(4);
+        pool.addProof(first);
+        pool.addProof(makeProof(2));
+        BOOST_CHECK_EQUAL(pool.getNStakes(), 6);
+        BOOST_CHECK_EQUAL(pool.getNProofs(), 2);
+
+        // The oldest proof has to be dropped
+        pool.addProof(makeProof(1));
+        BOOST_CHECK_EQUAL(pool.getNStakes(), 3);
+        BOOST_CHECK_EQUAL(pool.getNProofs(), 2);
+        BOOST_CHECK(!pool.getProof(first.getId()));
+    }
+
+    {
+        OrphanProofPool pool{15};
+        Proof first = makeProof(1);
+        pool.addProof(first);
+        Proof second = makeProof(2);
+        pool.addProof(second);
+        pool.addProof(makeProof(4));
+        pool.addProof(makeProof(8));
+        BOOST_CHECK_EQUAL(pool.getNStakes(), 15);
+        BOOST_CHECK_EQUAL(pool.getNProofs(), 4);
+
+        // Multiple proofs are dropped if needed
+        pool.addProof(makeProof(2));
+        BOOST_CHECK_EQUAL(pool.getNStakes(), 14);
+        BOOST_CHECK_EQUAL(pool.getNProofs(), 3);
+        BOOST_CHECK(!pool.getProof(first.getId()));
+        BOOST_CHECK(!pool.getProof(second.getId()));
+    }
+}
+
+BOOST_AUTO_TEST_CASE(remove_proofs) {
+    OrphanProofPool pool{1337};
+    std::array<ProofId, 10> aProofIds;
+
+    // Add 10 proofs
+    for (size_t i = 0; i < 10; i++) {
+        Proof p = makeProof(i + 1);
+        aProofIds[i] = p.getId();
+        BOOST_CHECK(pool.addProof(p));
+    }
+    BOOST_CHECK_EQUAL(pool.getNProofs(), 10);
+    BOOST_CHECK_EQUAL(pool.getNStakes(), 55);
+
+    // Remove a proof in the middle
+    BOOST_CHECK(pool.removeProof(aProofIds[5]));
+    BOOST_CHECK_EQUAL(pool.getNProofs(), 9);
+    BOOST_CHECK_EQUAL(pool.getNStakes(), 49);
+
+    // Remove a proof at the front
+    BOOST_CHECK(pool.removeProof(aProofIds[0]));
+    BOOST_CHECK_EQUAL(pool.getNProofs(), 8);
+    BOOST_CHECK_EQUAL(pool.getNStakes(), 48);
+
+    // Remove a proof at the back
+    BOOST_CHECK(pool.removeProof(aProofIds[9]));
+    BOOST_CHECK_EQUAL(pool.getNProofs(), 7);
+    BOOST_CHECK_EQUAL(pool.getNStakes(), 38);
+
+    // Fail to remove a proof that is longer in the pool
+    BOOST_CHECK(!pool.removeProof(aProofIds[5]));
+    BOOST_CHECK_EQUAL(pool.getNProofs(), 7);
+    BOOST_CHECK_EQUAL(pool.getNStakes(), 38);
+
+    // Fail to remove a proof that was never in the pool
+    Proof p = makeProof(11);
+    BOOST_CHECK(!pool.getProof(p.getId()));
+    BOOST_CHECK(!pool.removeProof(p.getId()));
+    BOOST_CHECK_EQUAL(pool.getNProofs(), 7);
+    BOOST_CHECK_EQUAL(pool.getNStakes(), 38);
+}
+
+BOOST_AUTO_TEST_CASE(add_proof_larger_than_pool) {
+    OrphanProofPool pool{AVALANCHE_MAX_PROOF_STAKES - 1};
+
+    // Add a couple of small proofs
+    BOOST_CHECK(pool.addProof(makeProof(1)));
+    BOOST_CHECK_EQUAL(pool.getNStakes(), 1);
+    BOOST_CHECK_EQUAL(pool.getNProofs(), 1);
+
+    BOOST_CHECK(pool.addProof(makeProof(2)));
+    BOOST_CHECK_EQUAL(pool.getNStakes(), 3);
+    BOOST_CHECK_EQUAL(pool.getNProofs(), 2);
+
+    // Adding a proof larger than the pool causes the pool to be emptied
+    BOOST_CHECK(pool.addProof(makeProof(AVALANCHE_MAX_PROOF_STAKES)));
+    BOOST_CHECK_EQUAL(pool.getNStakes(), 0);
+    BOOST_CHECK_EQUAL(pool.getNProofs(), 0);
+}
+
+BOOST_AUTO_TEST_SUITE_END()