diff --git a/src/test/fuzz/descriptor_parse.cpp b/src/test/fuzz/descriptor_parse.cpp
index a0880350b..77b208a40 100644
--- a/src/test/fuzz/descriptor_parse.cpp
+++ b/src/test/fuzz/descriptor_parse.cpp
@@ -1,20 +1,24 @@
 // Copyright (c) 2009-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chainparams.h>
+#include <pubkey.h>
 #include <script/descriptor.h>
 #include <test/fuzz/fuzz.h>
 
+#include <memory>
+
 void initialize() {
+    static const auto verify_handle = std::make_unique<ECCVerifyHandle>();
     SelectParams(CBaseChainParams::REGTEST);
 }
 
 void test_one_input(const std::vector<uint8_t> &buffer) {
     const std::string descriptor(buffer.begin(), buffer.end());
     FlatSigningProvider signing_provider;
     std::string error;
     for (const bool require_checksum : {true, false}) {
         Parse(descriptor, signing_provider, error, require_checksum);
     }
 }
diff --git a/src/test/fuzz/deserialize.cpp b/src/test/fuzz/deserialize.cpp
index 145ca71f5..9217b87a8 100644
--- a/src/test/fuzz/deserialize.cpp
+++ b/src/test/fuzz/deserialize.cpp
@@ -1,178 +1,184 @@
 // Copyright (c) 2009-2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <addrdb.h>
 #include <addrman.h>
 #include <blockencodings.h>
 #include <chain.h>
 #include <coins.h>
 #include <compressor.h>
 #include <consensus/merkle.h>
 #include <net.h>
 #include <primitives/block.h>
 #include <protocol.h>
+#include <pubkey.h>
 #include <streams.h>
 #include <undo.h>
 #include <version.h>
 
 #include <test/fuzz/fuzz.h>
 
 #include <cstdint>
 #include <unistd.h>
 #include <vector>
 
+void initialize() {
+    // Fuzzers using pubkey must hold an ECCVerifyHandle.
+    static const auto verify_handle = std::make_unique<ECCVerifyHandle>();
+}
+
 void test_one_input(const std::vector<uint8_t> &buffer) {
     CDataStream ds(buffer, SER_NETWORK, INIT_PROTO_VERSION);
     try {
         int nVersion;
         ds >> nVersion;
         ds.SetVersion(nVersion);
     } catch (const std::ios_base::failure &e) {
         return;
     }
 
 #if BLOCK_DESERIALIZE
     try {
         CBlock block;
         ds >> block;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif BLOCKLOCATOR_DESERIALIZE
     try {
         CBlockLocator bl;
         ds >> bl;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif BLOCKMERKLEROOT
     try {
         CBlock block;
         ds >> block;
         bool mutated;
         BlockMerkleRoot(block, &mutated);
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif ADDRMAN_DESERIALIZE
     try {
         CAddrMan am;
         ds >> am;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif BLOCKHEADER_DESERIALIZE
     try {
         CBlockHeader bh;
         ds >> bh;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif BANENTRY_DESERIALIZE
     try {
         CBanEntry be;
         ds >> be;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif TXUNDO_DESERIALIZE
     try {
         CTxUndo tu;
         ds >> tu;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif BLOCKUNDO_DESERIALIZE
     try {
         CBlockUndo bu;
         ds >> bu;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif COINS_DESERIALIZE
     try {
         Coin coin;
         ds >> coin;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif NETADDR_DESERIALIZE
     try {
         CNetAddr na;
         ds >> na;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif SERVICE_DESERIALIZE
     try {
         CService s;
         ds >> s;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif MESSAGEHEADER_DESERIALIZE
     CMessageHeader::MessageMagic pchMessageStart = {{0x00, 0x00, 0x00, 0x00}};
     try {
         CMessageHeader mh(pchMessageStart);
         ds >> mh;
         if (!mh.IsValidWithoutConfig(pchMessageStart)) {
             return;
         }
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif ADDRESS_DESERIALIZE
     try {
         CAddress a;
         ds >> a;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif INV_DESERIALIZE
     try {
         CInv i;
         ds >> i;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif BLOOMFILTER_DESERIALIZE
     try {
         CBloomFilter bf;
         ds >> bf;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif DISKBLOCKINDEX_DESERIALIZE
     try {
         CDiskBlockIndex dbi;
         ds >> dbi;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif TXOUTCOMPRESSOR_DESERIALIZE
     CTxOut to;
     CTxOutCompressor toc(to);
     try {
         ds >> toc;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif BLOCKTRANSACTIONS_DESERIALIZE
     try {
         BlockTransactions bt;
         ds >> bt;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif BLOCKTRANSACTIONSREQUEST_DESERIALIZE
     try {
         BlockTransactionsRequest btr;
         ds >> btr;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #else
 #error Need at least one fuzz target to compile
 #endif
 }
diff --git a/src/test/fuzz/eval_script.cpp b/src/test/fuzz/eval_script.cpp
index 8de64f364..b1e829971 100644
--- a/src/test/fuzz/eval_script.cpp
+++ b/src/test/fuzz/eval_script.cpp
@@ -1,31 +1,37 @@
 // Copyright (c) 2009-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <pubkey.h>
 #include <script/interpreter.h>
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
 
 #include <limits>
+#include <memory>
+
+void initialize() {
+    static const auto verify_handle = std::make_unique<ECCVerifyHandle>();
+}
 
 void test_one_input(const std::vector<uint8_t> &buffer) {
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
     const unsigned int flags =
         fuzzed_data_provider.ConsumeIntegral<unsigned int>();
     const std::vector<uint8_t> script_bytes = [&] {
         if (fuzzed_data_provider.remaining_bytes() != 0) {
             return fuzzed_data_provider.ConsumeRemainingBytes<uint8_t>();
         } else {
             // Avoid UBSan warning:
             //   test/fuzz/FuzzedDataProvider.h:212:17: runtime error: null
             //   pointer passed as argument 1, which is declared to never be
             //   null /usr/include/string.h:43:28: note: nonnull attribute
             //   specified here
             return std::vector<uint8_t>();
         }
     }();
     const CScript script(script_bytes.begin(), script_bytes.end());
     std::vector<std::vector<uint8_t>> stack;
     ScriptExecutionMetrics metrics;
     (void)EvalScript(stack, script, flags, BaseSignatureChecker(), metrics);
 }
diff --git a/src/test/fuzz/fuzz.cpp b/src/test/fuzz/fuzz.cpp
index 8e680cbcf..214f85f14 100644
--- a/src/test/fuzz/fuzz.cpp
+++ b/src/test/fuzz/fuzz.cpp
@@ -1,75 +1,68 @@
 // Copyright (c) 2009-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <test/fuzz/fuzz.h>
 
-#include <pubkey.h>
-
-#include <memory>
+#include <cstdint>
 #include <unistd.h>
+#include <vector>
 
 static bool read_stdin(std::vector<uint8_t> &data) {
     uint8_t buffer[1024];
     ssize_t length = 0;
     while ((length = read(STDIN_FILENO, buffer, 1024)) > 0) {
         data.insert(data.end(), buffer, buffer + length);
 
         if (data.size() > (1 << 20)) {
             return false;
         }
     }
     return length == 0;
 }
 
 // Default initialization: Override using a non-weak initialize().
-__attribute__((weak)) void initialize() {
-    const static auto verify_handle = std::make_unique<ECCVerifyHandle>();
-}
+__attribute__((weak)) void initialize() {}
 
 // This function is used by libFuzzer
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
     const std::vector<uint8_t> input(data, data + size);
     test_one_input(input);
     return 0;
 }
 
 // This function is used by libFuzzer
 extern "C" int LLVMFuzzerInitialize(int *argc, char ***argv) {
     initialize();
     return 0;
 }
 
-// Disabled under WIN32 due to clash with Cygwin's WinMain.
-#ifndef WIN32
 // Declare main(...) "weak" to allow for libFuzzer linking. libFuzzer provides
 // the main(...) function.
-__attribute__((weak))
-#endif
-int main(int argc, char **argv) {
+__attribute__((weak)) int main(int argc, char **argv) {
     initialize();
 #ifdef __AFL_INIT
     // Enable AFL deferred forkserver mode. Requires compilation using
     // afl-clang-fast++. See fuzzing.md for details.
     __AFL_INIT();
 #endif
 
 #ifdef __AFL_LOOP
     // Enable AFL persistent mode. Requires compilation using afl-clang-fast++.
     // See fuzzing.md for details.
     while (__AFL_LOOP(1000)) {
         std::vector<uint8_t> buffer;
         if (!read_stdin(buffer)) {
             continue;
         }
         test_one_input(buffer);
     }
 #else
     std::vector<uint8_t> buffer;
     if (!read_stdin(buffer)) {
         return 0;
     }
     test_one_input(buffer);
 #endif
     return 0;
 }
diff --git a/src/test/fuzz/script_flags.cpp b/src/test/fuzz/script_flags.cpp
index 823ab5ff8..e8a530381 100644
--- a/src/test/fuzz/script_flags.cpp
+++ b/src/test/fuzz/script_flags.cpp
@@ -1,78 +1,85 @@
 // Copyright (c) 2009-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <pubkey.h>
 #include <script/interpreter.h>
 #include <streams.h>
 #include <version.h>
 
 #include <test/fuzz/fuzz.h>
 
+#include <memory>
+
 /** Flags that are not forbidden by an assert */
 static bool IsValidFlagCombination(uint32_t flags);
 
+void initialize() {
+    static const auto verify_handle = std::make_unique<ECCVerifyHandle>();
+}
+
 void test_one_input(const std::vector<uint8_t> &buffer) {
     CDataStream ds(buffer, SER_NETWORK, INIT_PROTO_VERSION);
     try {
         int nVersion;
         ds >> nVersion;
         ds.SetVersion(nVersion);
     } catch (const std::ios_base::failure &) {
         return;
     }
 
     try {
         const CTransaction tx(deserialize, ds);
         const PrecomputedTransactionData txdata(tx);
 
         uint32_t verify_flags;
         ds >> verify_flags;
 
         if (!IsValidFlagCombination(verify_flags)) {
             return;
         }
 
         uint32_t fuzzed_flags;
         ds >> fuzzed_flags;
 
         for (unsigned int i = 0; i < tx.vin.size(); ++i) {
             CTxOut prevout;
             ds >> prevout;
 
             const TransactionSignatureChecker checker{&tx, i, prevout.nValue,
                                                       txdata};
 
             ScriptError serror;
             const bool ret =
                 VerifyScript(tx.vin.at(i).scriptSig, prevout.scriptPubKey,
                              verify_flags, checker, &serror);
             assert(ret == (serror == ScriptError::OK));
 
             // Verify that removing flags from a passing test or adding flags to
             // a failing test does not change the result
             if (ret) {
                 verify_flags &= ~fuzzed_flags;
             } else {
                 verify_flags |= fuzzed_flags;
             }
             if (!IsValidFlagCombination(verify_flags)) {
                 return;
             }
 
             ScriptError serror_fuzzed;
             const bool ret_fuzzed =
                 VerifyScript(tx.vin.at(i).scriptSig, prevout.scriptPubKey,
                              verify_flags, checker, &serror_fuzzed);
             assert(ret_fuzzed == (serror_fuzzed == ScriptError::OK));
 
             assert(ret_fuzzed == ret);
         }
     } catch (const std::ios_base::failure &) {
         return;
     }
 }
 
 static bool IsValidFlagCombination(uint32_t flags) {
     // If the CLEANSTACK flag is set, then P2SH should also be set
     return (~flags & SCRIPT_VERIFY_CLEANSTACK) || (flags & SCRIPT_VERIFY_P2SH);
 }