diff --git a/src/test/compress_tests.cpp b/src/test/compress_tests.cpp
index cd19e385da..deb5c6177c 100644
--- a/src/test/compress_tests.cpp
+++ b/src/test/compress_tests.cpp
@@ -5,6 +5,7 @@
 #include <compressor.h>
 #include <util/system.h>
 #include <test/setup_common.h>
+#include <script/standard.h>
 
 #include <stdint.h>
 
@@ -62,4 +63,76 @@ BOOST_AUTO_TEST_CASE(compress_amounts)
         BOOST_CHECK(TestDecode(i));
 }
 
+BOOST_AUTO_TEST_CASE(compress_script_to_ckey_id)
+{
+    // case CKeyID
+    CKey key;
+    key.MakeNewKey(true);
+    CPubKey pubkey = key.GetPubKey();
+
+    CScript script = CScript() << OP_DUP << OP_HASH160 << ToByteVector(pubkey.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
+    BOOST_CHECK_EQUAL(script.size(), 25);
+
+    std::vector<unsigned char> out;
+    bool done = CompressScript(script, out);
+    BOOST_CHECK_EQUAL(done, true);
+
+    // Check compressed script
+    BOOST_CHECK_EQUAL(out.size(), 21);
+    BOOST_CHECK_EQUAL(out[0], 0x00);
+    BOOST_CHECK_EQUAL(memcmp(&out[1], &script[3], 20), 0); // compare the 20 relevant chars of the CKeyId in the script
+}
+
+BOOST_AUTO_TEST_CASE(compress_script_to_cscript_id)
+{
+    // case CScriptID
+    CScript script, redeemScript;
+    script << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
+    BOOST_CHECK_EQUAL(script.size(), 23);
+
+    std::vector<unsigned char> out;
+    bool done = CompressScript(script, out);
+    BOOST_CHECK_EQUAL(done, true);
+
+    // Check compressed script
+    BOOST_CHECK_EQUAL(out.size(), 21);
+    BOOST_CHECK_EQUAL(out[0], 0x01);
+    BOOST_CHECK_EQUAL(memcmp(&out[1], &script[2], 20), 0); // compare the 20 relevant chars of the CScriptId in the script
+}
+
+BOOST_AUTO_TEST_CASE(compress_script_to_compressed_pubkey_id)
+{
+    CKey key;
+    key.MakeNewKey(true); // case compressed PubKeyID
+
+    CScript script = CScript() << ToByteVector(key.GetPubKey()) << OP_CHECKSIG; // COMPRESSED_PUBLIC_KEY_SIZE (33)
+    BOOST_CHECK_EQUAL(script.size(), 35);
+
+    std::vector<unsigned char> out;
+    bool done = CompressScript(script, out);
+    BOOST_CHECK_EQUAL(done, true);
+
+    // Check compressed script
+    BOOST_CHECK_EQUAL(out.size(), 33);
+    BOOST_CHECK_EQUAL(memcmp(&out[0], &script[1], 1), 0);
+    BOOST_CHECK_EQUAL(memcmp(&out[1], &script[2], 32), 0); // compare the 32 chars of the compressed CPubKey
+}
+
+BOOST_AUTO_TEST_CASE(compress_script_to_uncompressed_pubkey_id)
+{
+    CKey key;
+    key.MakeNewKey(false); // case uncompressed PubKeyID
+    CScript script =  CScript() << ToByteVector(key.GetPubKey()) << OP_CHECKSIG; // PUBLIC_KEY_SIZE (65)
+    BOOST_CHECK_EQUAL(script.size(), 67);                   // 1 char code + 65 char pubkey + OP_CHECKSIG
+
+    std::vector<unsigned char> out;
+    bool done = CompressScript(script, out);
+    BOOST_CHECK_EQUAL(done, true);
+
+    // Check compressed script
+    BOOST_CHECK_EQUAL(out.size(), 33);
+    BOOST_CHECK_EQUAL(memcmp(&out[1], &script[2], 32), 0); // first 32 chars of CPubKey are copied into out[1:]
+    BOOST_CHECK_EQUAL(out[0], 0x04 | (script[65] & 0x01)); // least significant bit (lsb) of last char of pubkey is mapped into out[0]
+}
+
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/timedata_tests.cpp b/src/test/timedata_tests.cpp
index aca1ca8ffb..147172aeba 100644
--- a/src/test/timedata_tests.cpp
+++ b/src/test/timedata_tests.cpp
@@ -2,8 +2,14 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 //
-#include <timedata.h>
+
+#include <netaddress.h>
+#include <noui.h>
 #include <test/setup_common.h>
+#include <timedata.h>
+#include <warnings.h>
+
+#include <string>
 
 #include <boost/test/unit_test.hpp>
 
@@ -34,4 +40,61 @@ BOOST_AUTO_TEST_CASE(util_MedianFilter)
     BOOST_CHECK_EQUAL(filter.median(), 7);
 }
 
+static void MultiAddTimeData(int n, int64_t offset)
+{
+    static int cnt = 0;
+    for (int i = 0; i < n; ++i) {
+        CNetAddr addr;
+        addr.SetInternal(std::to_string(++cnt));
+        AddTimeData(addr, offset);
+    }
+}
+
+
+BOOST_AUTO_TEST_CASE(addtimedata)
+{
+    BOOST_CHECK_EQUAL(GetTimeOffset(), 0);
+
+    //Part 1: Add large offsets to test a warning message that our clock may be wrong.
+    MultiAddTimeData(3, DEFAULT_MAX_TIME_ADJUSTMENT + 1);
+    // Filter size is 1 + 3 = 4: It is always initialized with a single element (offset 0)
+
+    noui_suppress();
+    MultiAddTimeData(1, DEFAULT_MAX_TIME_ADJUSTMENT + 1); //filter size 5
+    noui_reconnect();
+
+    BOOST_CHECK(GetWarnings("gui").find("clock is wrong") != std::string::npos);
+
+    // nTimeOffset is not changed if the median of offsets exceeds DEFAULT_MAX_TIME_ADJUSTMENT
+    BOOST_CHECK_EQUAL(GetTimeOffset(), 0);
+
+    // Part 2: Test positive and negative medians by adding more offsets
+    MultiAddTimeData(4, 100); // filter size 9
+    BOOST_CHECK_EQUAL(GetTimeOffset(), 100);
+    MultiAddTimeData(10, -100); //filter size 19
+    BOOST_CHECK_EQUAL(GetTimeOffset(), -100);
+
+    // Part 3: Test behaviour when filter has reached maximum number of offsets
+    const int MAX_SAMPLES = 200;
+    int nfill = (MAX_SAMPLES - 3 - 19) / 2; //89
+    MultiAddTimeData(nfill, 100);
+    MultiAddTimeData(nfill, -100); //filter size MAX_SAMPLES - 3
+    BOOST_CHECK_EQUAL(GetTimeOffset(), -100);
+
+    MultiAddTimeData(2, 100);
+    //filter size MAX_SAMPLES -1, median is the initial 0 offset
+    //since we added same number of positive/negative offsets
+
+    BOOST_CHECK_EQUAL(GetTimeOffset(), 0);
+
+    // After the number of offsets has reached MAX_SAMPLES -1 (=199), nTimeOffset will never change
+    // because it is only updated when the number of elements in the filter becomes odd. It was decided
+    // not to fix this because it prevents possible attacks. See the comment in AddTimeData() or issue #4521
+    // for a more detailed explanation.
+    MultiAddTimeData(2, 100); // filter median is 100 now, but nTimeOffset will not change
+    BOOST_CHECK_EQUAL(GetTimeOffset(), 0);
+
+    // We want this test to end with nTimeOffset==0, otherwise subsequent tests of the suite will fail.
+}
+
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/txdb.cpp b/src/txdb.cpp
index 7cb0f67dca..8615214bf4 100644
--- a/src/txdb.cpp
+++ b/src/txdb.cpp
@@ -139,7 +139,7 @@ size_t CCoinsViewDB::EstimateSize() const
     return db.EstimateSize(DB_COIN, (char)(DB_COIN+1));
 }
 
-CBlockTreeDB::CBlockTreeDB(size_t nCacheSize, bool fMemory, bool fWipe) : CDBWrapper(gArgs.IsArgSet("-blocksdir") ? GetDataDir() / "blocks" / "index" : GetBlocksDir() / "index", nCacheSize, fMemory, fWipe) {
+CBlockTreeDB::CBlockTreeDB(size_t nCacheSize, bool fMemory, bool fWipe) : CDBWrapper(GetDataDir() / "blocks" / "index", nCacheSize, fMemory, fWipe) {
 }
 
 bool CBlockTreeDB::ReadBlockFileInfo(int nFile, CBlockFileInfo &info) {
diff --git a/src/validation.cpp b/src/validation.cpp
index d1a4e238bf..240b7e18c9 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -75,12 +75,12 @@ static const unsigned int MAX_DISCONNECTED_TX_POOL_SIZE = 20000;
 static const unsigned int BLOCKFILE_CHUNK_SIZE = 0x1000000; // 16 MiB
 /** The pre-allocation chunk size for rev?????.dat files (since 0.8) */
 static const unsigned int UNDOFILE_CHUNK_SIZE = 0x100000; // 1 MiB
-/** Time to wait (in seconds) between writing blocks/block index to disk. */
-static const unsigned int DATABASE_WRITE_INTERVAL = 60 * 60;
-/** Time to wait (in seconds) between flushing chainstate to disk. */
-static const unsigned int DATABASE_FLUSH_INTERVAL = 24 * 60 * 60;
-/** Maximum age of our tip in seconds for us to be considered current for fee estimation */
-static const int64_t MAX_FEE_ESTIMATION_TIP_AGE = 3 * 60 * 60;
+/** Time to wait between writing blocks/block index to disk. */
+static constexpr std::chrono::hours DATABASE_WRITE_INTERVAL{1};
+/** Time to wait between flushing chainstate to disk. */
+static constexpr std::chrono::hours DATABASE_FLUSH_INTERVAL{24};
+/** Maximum age of our tip for us to be considered current for fee estimation */
+static constexpr std::chrono::hours MAX_FEE_ESTIMATION_TIP_AGE{3};
 
 bool CBlockIndexWorkComparator::operator()(const CBlockIndex* pa, const CBlockIndex* pb) const
 {
@@ -419,7 +419,7 @@ static bool IsCurrentForFeeEstimation() EXCLUSIVE_LOCKS_REQUIRED(cs_main)
     AssertLockHeld(cs_main);
     if (::ChainstateActive().IsInitialBlockDownload())
         return false;
-    if (::ChainActive().Tip()->GetBlockTime() < (GetTime() - MAX_FEE_ESTIMATION_TIP_AGE))
+    if (::ChainActive().Tip()->GetBlockTime() < count_seconds(GetTime<std::chrono::seconds>() - MAX_FEE_ESTIMATION_TIP_AGE))
         return false;
     if (::ChainActive().Height() < pindexBestHeader->nHeight - 1)
         return false;
@@ -2432,8 +2432,8 @@ bool CChainState::FlushStateToDisk(
 {
     LOCK(cs_main);
     assert(this->CanFlushToDisk());
-    static int64_t nLastWrite = 0;
-    static int64_t nLastFlush = 0;
+    static std::chrono::microseconds nLastWrite{0};
+    static std::chrono::microseconds nLastFlush{0};
     std::set<int> setFilesToPrune;
     bool full_flush_completed = false;
 
@@ -2465,12 +2465,12 @@ bool CChainState::FlushStateToDisk(
                 }
             }
         }
-        int64_t nNow = GetTimeMicros();
+        const auto nNow = GetTime<std::chrono::microseconds>();
         // Avoid writing/flushing immediately after startup.
-        if (nLastWrite == 0) {
+        if (nLastWrite.count() == 0) {
             nLastWrite = nNow;
         }
-        if (nLastFlush == 0) {
+        if (nLastFlush.count() == 0) {
             nLastFlush = nNow;
         }
         // The cache is large and we're within 10% and 10 MiB of the limit, but we have time now (not in the middle of a block processing).
@@ -2478,9 +2478,9 @@ bool CChainState::FlushStateToDisk(
         // The cache is over the limit, we have to write now.
         bool fCacheCritical = mode == FlushStateMode::IF_NEEDED && cache_state >= CoinsCacheSizeState::CRITICAL;
         // It's been a while since we wrote the block index to disk. Do this frequently, so we don't need to redownload after a crash.
-        bool fPeriodicWrite = mode == FlushStateMode::PERIODIC && nNow > nLastWrite + (int64_t)DATABASE_WRITE_INTERVAL * 1000000;
+        bool fPeriodicWrite = mode == FlushStateMode::PERIODIC && nNow > nLastWrite + DATABASE_WRITE_INTERVAL;
         // It's been very long since we flushed the cache. Do this infrequently, to optimize cache usage.
-        bool fPeriodicFlush = mode == FlushStateMode::PERIODIC && nNow > nLastFlush + (int64_t)DATABASE_FLUSH_INTERVAL * 1000000;
+        bool fPeriodicFlush = mode == FlushStateMode::PERIODIC && nNow > nLastFlush + DATABASE_FLUSH_INTERVAL;
         // Combine all conditions that result in a full cache flush.
         fDoFullFlush = (mode == FlushStateMode::ALWAYS) || fCacheLarge || fCacheCritical || fPeriodicFlush || fFlushForPrune;
         // Write blocks and block index to disk.
diff --git a/src/wallet/test/db_tests.cpp b/src/wallet/test/db_tests.cpp
index d9b07af329..bed14ea7b1 100644
--- a/src/wallet/test/db_tests.cpp
+++ b/src/wallet/test/db_tests.cpp
@@ -23,8 +23,8 @@ BOOST_AUTO_TEST_CASE(getwalletenv_file)
 
     std::string filename;
     std::shared_ptr<BerkeleyEnvironment> env = GetWalletEnv(file_path, filename);
-    BOOST_CHECK(filename == test_name);
-    BOOST_CHECK(env->Directory() == datadir);
+    BOOST_CHECK_EQUAL(filename, test_name);
+    BOOST_CHECK_EQUAL(env->Directory(), datadir);
 }
 
 BOOST_AUTO_TEST_CASE(getwalletenv_directory)
@@ -34,8 +34,8 @@ BOOST_AUTO_TEST_CASE(getwalletenv_directory)
 
     std::string filename;
     std::shared_ptr<BerkeleyEnvironment> env = GetWalletEnv(datadir, filename);
-    BOOST_CHECK(filename == expected_name);
-    BOOST_CHECK(env->Directory() == datadir);
+    BOOST_CHECK_EQUAL(filename, expected_name);
+    BOOST_CHECK_EQUAL(env->Directory(), datadir);
 }
 
 BOOST_AUTO_TEST_CASE(getwalletenv_g_dbenvs_multiple)
diff --git a/src/wallet/test/init_tests.cpp b/src/wallet/test/init_tests.cpp
index 49b7218215..f8666205e4 100644
--- a/src/wallet/test/init_tests.cpp
+++ b/src/wallet/test/init_tests.cpp
@@ -24,7 +24,7 @@ BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_default)
     BOOST_CHECK(result == true);
     fs::path walletdir = gArgs.GetArg("-walletdir", "");
     fs::path expected_path = fs::canonical(m_walletdir_path_cases["default"]);
-    BOOST_CHECK(walletdir == expected_path);
+    BOOST_CHECK_EQUAL(walletdir, expected_path);
 }
 
 BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_custom)
@@ -36,7 +36,7 @@ BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_custom)
     BOOST_CHECK(result == true);
     fs::path walletdir = gArgs.GetArg("-walletdir", "");
     fs::path expected_path = fs::canonical(m_walletdir_path_cases["custom"]);
-    BOOST_CHECK(walletdir == expected_path);
+    BOOST_CHECK_EQUAL(walletdir, expected_path);
 }
 
 BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_does_not_exist)
@@ -75,7 +75,7 @@ BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_no_trailing)
     BOOST_CHECK(result == true);
     fs::path walletdir = gArgs.GetArg("-walletdir", "");
     fs::path expected_path = fs::canonical(m_walletdir_path_cases["default"]);
-    BOOST_CHECK(walletdir == expected_path);
+    BOOST_CHECK_EQUAL(walletdir, expected_path);
 }
 
 BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_no_trailing2)
@@ -87,7 +87,7 @@ BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_no_trailing2)
     BOOST_CHECK(result == true);
     fs::path walletdir = gArgs.GetArg("-walletdir", "");
     fs::path expected_path = fs::canonical(m_walletdir_path_cases["default"]);
-    BOOST_CHECK(walletdir == expected_path);
+    BOOST_CHECK_EQUAL(walletdir, expected_path);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/walletinitinterface.h b/src/walletinitinterface.h
index fb96dce97c..4b579569c8 100644
--- a/src/walletinitinterface.h
+++ b/src/walletinitinterface.h
@@ -5,10 +5,6 @@
 #ifndef BITCOIN_WALLETINITINTERFACE_H
 #define BITCOIN_WALLETINITINTERFACE_H
 
-#include <string>
-
-class CScheduler;
-class CRPCTable;
 struct InitInterfaces;
 
 class WalletInitInterface {
diff --git a/test/functional/feature_pruning.py b/test/functional/feature_pruning.py
index 274abcd40d..a6d40cf0d7 100755
--- a/test/functional/feature_pruning.py
+++ b/test/functional/feature_pruning.py
@@ -198,6 +198,7 @@ class PruneTest(BitcoinTestFramework):
         self.log.info("Mine 220 more large blocks so we have requisite history")
 
         mine_large_blocks(self.nodes[0], 220)
+        self.sync_blocks(self.nodes[0:3], timeout=120)
 
         usage = calc_usage(self.prunedir)
         self.log.info("Usage should be below target: %d" % usage)