diff --git a/cmake/modules/ExternalLibraryHelper.cmake b/cmake/modules/ExternalLibraryHelper.cmake
index c80c91fa1..b4251a010 100644
--- a/cmake/modules/ExternalLibraryHelper.cmake
+++ b/cmake/modules/ExternalLibraryHelper.cmake
@@ -1,58 +1,58 @@
 include(FindPackageMessage)
 
 # Find a library component, set the variables and create an imported target.
 # Variable names are compliant with cmake standards.
 function(find_component LIB COMPONENT)
 	cmake_parse_arguments(ARG
 		""
 		""
 		"HINTS;INCLUDE_DIRS;INTERFACE_LINK_LIBRARIES;NAMES;PATHS;PATH_SUFFIXES"
 		${ARGN}
 	)
 
 	# If the component is not requested, skip the search.
 	if(${LIB}_FIND_COMPONENTS AND NOT ${COMPONENT} IN_LIST ${LIB}_FIND_COMPONENTS)
 		return()
 	endif()
 
 	find_library(${LIB}_${COMPONENT}_LIBRARY
 		NAMES ${ARG_NAMES}
 		PATHS "" ${ARG_PATHS}
 		HINTS "" ${ARG_HINTS}
-		PATH_SUFFIXES "" ${ARG_PATH_SUFFIXES}
+		PATH_SUFFIXES "lib" ${ARG_PATH_SUFFIXES}
 	)
 	mark_as_advanced(${LIB}_${COMPONENT}_LIBRARY)
 
 	if(${LIB}_${COMPONENT}_LIBRARY)
 		# On success, set the standard FOUND variable...
 		set(${LIB}_${COMPONENT}_FOUND TRUE PARENT_SCOPE)
 
 		# ... and append the library path to the LIBRARIES variable ...
 		list(APPEND ${LIB}_LIBRARIES
 			"${${LIB}_${COMPONENT}_LIBRARY}"
 			${ARG_INTERFACE_LINK_LIBRARIES}
 		)
 		list(REMOVE_DUPLICATES ${LIB}_LIBRARIES)
 		set(${LIB}_LIBRARIES ${${LIB}_LIBRARIES} PARENT_SCOPE)
 
 		# ... and create an imported target for the component, if not already
 		# done.
 		if(NOT TARGET ${LIB}::${COMPONENT})
 			add_library(${LIB}::${COMPONENT} UNKNOWN IMPORTED)
 			set_target_properties(${LIB}::${COMPONENT} PROPERTIES
 				IMPORTED_LOCATION "${${LIB}_${COMPONENT}_LIBRARY}"
 			)
 			set_property(TARGET ${LIB}::${COMPONENT} PROPERTY
 				INTERFACE_INCLUDE_DIRECTORIES ${ARG_INCLUDE_DIRS}
 			)
 			set_property(TARGET ${LIB}::${COMPONENT} PROPERTY
 				INTERFACE_LINK_LIBRARIES ${ARG_INTERFACE_LINK_LIBRARIES}
 			)
 		endif()
 
 		find_package_message("${LIB}_${COMPONENT}"
 			"Found ${LIB} component ${COMPONENT}: ${${LIB}_${COMPONENT}_LIBRARY}"
 			"[${${LIB}_${COMPONENT}_LIBRARY}][${ARG_INCLUDE_DIRS}]"
 		)
 	endif()
 endfunction()
diff --git a/cmake/modules/FindBerkeleyDB.cmake b/cmake/modules/FindBerkeleyDB.cmake
index 409db4bb2..62211dfb9 100644
--- a/cmake/modules/FindBerkeleyDB.cmake
+++ b/cmake/modules/FindBerkeleyDB.cmake
@@ -1,166 +1,167 @@
 # Copyright (c) 2017-2020 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #.rst
 # FindBerkeleyDB
 # -------------
 #
 # This is inspired by https://github.com/sum01/FindBerkeleyDB.
 #
 # Find the Berkeley database (versions >= 5.x) libraries The following
 # components are available::
 #   C
 #   CXX
 #
 # This will define the following variables::
 #
 #   BerkeleyDB_FOUND - system has Berkeley DB lib
 #   BerkeleyDB_INCLUDE_DIRS - the Berkeley DB include directories
 #   BerkeleyDB_LIBRARIES - Libraries needed to use Berkeley DB
 #   BerkeleyDB_VERSION - The library version MAJOR.MINOR.PATCH
 #   BerkeleyDB_VERSION_MAJOR - Major version number
 #   BerkeleyDB_VERSION_MINOR - Minor version number
 #   BerkeleyDB_VERSION_PATCH - Patch version number
 #
 # And the following imported target::
 #
 #   BerkeleyDB::C
 #   BerkeleyDB::CXX
 
 # Generate a list of all the possible versioned library name variants given a
 # list of separators.
 function(generate_versions_variants VARIANTS LIB MAJOR MINOR)
 	set(SEPARATORS
 		"" "." "-" "_"
 	)
 
 	set(${VARIANTS} "${LIB}")
 	foreach(_separator1 IN LISTS SEPARATORS)
 		list(APPEND ${VARIANTS} "${LIB}${_separator1}${MAJOR}")
 		foreach(_separator2 IN LISTS SEPARATORS)
 			list(APPEND ${VARIANTS} "${LIB}${_separator1}${MAJOR}${_separator2}${MINOR}")
 		endforeach()
 	endforeach()
 
 	set(${VARIANTS} ${${VARIANTS}} PARENT_SCOPE)
 endfunction()
 
 include(BrewHelper)
-find_brew_prefix(BREW_HINT berkeley-db)
+find_brew_prefix(_BerkeleyDB_BREW_HINT berkeley-db)
 
 # If the include directory is user supplied, skip the search
 if(NOT BerkeleyDB_INCLUDE_DIR)
 	# Berkeley DB 5 including latest minor release.
 	generate_versions_variants(_BerkeleyDB_PATH_SUFFIXES_5_3 db 5 3)
 	# Berkeley DB 6 including latest minor release.
 	generate_versions_variants(_BerkeleyDB_PATH_SUFFIXES_6_2 db 6 2)
 	# Berkeley DB 18 including latest minor release (current).
 	generate_versions_variants(_BerkeleyDB_PATH_SUFFIXES_18_1 db 18 1)
 
 	set(_BerkeleyDB_PATH_SUFFIXES
+		include
 		${_BerkeleyDB_PATH_SUFFIXES_5_3}
 		${_BerkeleyDB_PATH_SUFFIXES_6_2}
 		${_BerkeleyDB_PATH_SUFFIXES_18_1}
 	)
 	list(REMOVE_DUPLICATES _BerkeleyDB_PATH_SUFFIXES)
 
 	# Try to find the db.h header.
 	# If the header is not found the user can supply the correct path by passing
 	# the `BerkeleyDB_ROOT` variable to cmake.
 	find_path(BerkeleyDB_INCLUDE_DIR
 		NAMES db.h
-		HINTS ${BREW_HINT}
+		HINTS ${_BerkeleyDB_BREW_HINT}
 		PATH_SUFFIXES ${_BerkeleyDB_PATH_SUFFIXES}
 	)
 endif()
 
 # There is a single common include directory.
 # Set the BerkeleyDB_INCLUDE_DIRS variable which is the expected standard output
 # variable name for the include directories.
 set(BerkeleyDB_INCLUDE_DIRS "${BerkeleyDB_INCLUDE_DIR}")
 mark_as_advanced(BerkeleyDB_INCLUDE_DIR)
 
 if(BerkeleyDB_INCLUDE_DIR)
 	# Extract version information from the db.h header.
 	if(NOT DEFINED BerkeleyDB_VERSION)
 		# Read the version from file db.h into a variable.
 		file(READ "${BerkeleyDB_INCLUDE_DIR}/db.h" _BerkeleyDB_DB_HEADER)
 
 		# Parse the version into variables.
 		string(REGEX REPLACE
 			".*DB_VERSION_MAJOR[ \t]+([0-9]+).*" "\\1"
 			BerkeleyDB_VERSION_MAJOR
 			"${_BerkeleyDB_DB_HEADER}"
 		)
 		string(REGEX REPLACE
 			".*DB_VERSION_MINOR[ \t]+([0-9]+).*" "\\1"
 			BerkeleyDB_VERSION_MINOR
 			"${_BerkeleyDB_DB_HEADER}"
 		)
 		# Patch version example on non-crypto installs: x.x.xNC
 		string(REGEX REPLACE
 			".*DB_VERSION_PATCH[ \t]+([0-9]+(NC)?).*" "\\1"
 			BerkeleyDB_VERSION_PATCH
 			"${_BerkeleyDB_DB_HEADER}"
 		)
 
 		# Cache the result.
 		set(BerkeleyDB_VERSION_MAJOR ${BerkeleyDB_VERSION_MAJOR}
 			CACHE INTERNAL "BerekeleyDB major version number"
 		)
 		set(BerkeleyDB_VERSION_MINOR ${BerkeleyDB_VERSION_MINOR}
 			CACHE INTERNAL "BerekeleyDB minor version number"
 		)
 		set(BerkeleyDB_VERSION_PATCH ${BerkeleyDB_VERSION_PATCH}
 			CACHE INTERNAL "BerekeleyDB patch version number"
 		)
 		# The actual returned/output version variable (the others can be used if
 		# needed).
 		set(BerkeleyDB_VERSION
 			"${BerkeleyDB_VERSION_MAJOR}.${BerkeleyDB_VERSION_MINOR}.${BerkeleyDB_VERSION_PATCH}"
 			CACHE INTERNAL "BerekeleyDB full version"
 		)
 	endif()
 
 	include(ExternalLibraryHelper)
 
 	# Different systems sometimes have a version in the lib name...
 	# and some have a dash or underscore before the versions.
 	# Generate all combinations from the separators "" (none), ".", "-" and "_".
 	generate_versions_variants(
 		_db_variants
 		db
 		"${BerkeleyDB_VERSION_MAJOR}"
 		"${BerkeleyDB_VERSION_MINOR}"
 	)
 
 	find_component(BerkeleyDB C
 		NAMES ${_db_variants}
-		HINTS ${BREW_HINT}
+		HINTS ${_BerkeleyDB_BREW_HINT}
 		PATH_SUFFIXES ${_db_variants}
 		INCLUDE_DIRS ${BerkeleyDB_INCLUDE_DIRS}
 	)
 
 	generate_versions_variants(
 		_db_cxx_variants
 		db_cxx
 		"${BerkeleyDB_VERSION_MAJOR}"
 		"${BerkeleyDB_VERSION_MINOR}"
 	)
 
 	find_component(BerkeleyDB CXX
 		NAMES ${_db_cxx_variants}
-		HINTS ${BREW_HINT}
+		HINTS ${_BerkeleyDB_BREW_HINT}
 		PATH_SUFFIXES ${_db_variants}
 		INCLUDE_DIRS ${BerkeleyDB_INCLUDE_DIRS}
 	)
 endif()
 
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(BerkeleyDB
 	REQUIRED_VARS
 		BerkeleyDB_INCLUDE_DIR
 	VERSION_VAR BerkeleyDB_VERSION
 	HANDLE_COMPONENTS
 )
diff --git a/cmake/modules/FindEvent.cmake b/cmake/modules/FindEvent.cmake
index 82400ce4a..06702cd75 100644
--- a/cmake/modules/FindEvent.cmake
+++ b/cmake/modules/FindEvent.cmake
@@ -1,88 +1,89 @@
 # Copyright (c) 2017-2020 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #.rst
 # FindEvent
 # -------------
 #
 # Find the Event library. The following components are available::
 #
 #   event
 #   pthreads
 #
 # This will define the following variables::
 #
 #   Event_FOUND - system has Event lib
 #   Event_INCLUDE_DIRS - the Event include directories
 #   Event_LIBRARIES - Libraries needed to use Event
 #   Event_VERSION - The library version MAJOR.MINOR.PATCH
 #
 # And the following imported target::
 #
 #   Event::event
 #   Event::pthreads
 
 find_package(PkgConfig)
 pkg_check_modules(PC_Event QUIET libevent)
 
 include(BrewHelper)
-find_brew_prefix(BREW_HINT berkeley-db)
+find_brew_prefix(_Event_BREW_HINT libevent)
 
 find_path(Event_INCLUDE_DIR
 	NAMES event.h
 	PATHS ${PC_Event_INCLUDE_DIRS}
-	HINTS ${BREW_HINT}
+	HINTS ${_Event_BREW_HINT}
+	PATH_SUFFIXES include
 )
 
 set(Event_INCLUDE_DIRS ${Event_INCLUDE_DIR})
 mark_as_advanced(Event_INCLUDE_DIR)
 
 if(Event_INCLUDE_DIR)
 	include(ExternalLibraryHelper)
 
 	find_component(Event event
 		NAMES event
-		HINTS "${BREW_HINT}"
+		HINTS "${_Event_BREW_HINT}"
 		INCLUDE_DIRS ${Event_INCLUDE_DIRS}
 		PATHS ${PC_Event_LIBRARY_DIRS}
 		INTERFACE_LINK_LIBRARIES "$<$<PLATFORM_ID:Windows>:ws2_32;shell32;advapi32>"
 	)
 
 	pkg_check_modules(PC_Event_pthreads QUIET event_pthreads libevent_pthreads)
 	find_component(Event pthreads
 		NAMES event_pthreads
 		INCLUDE_DIRS ${Event_INCLUDE_DIRS}
 		PATHS ${PC_Event_pthreads_LIBRARY_DIRS}
 	)
 
 	if(NOT Event_VERSION)
 		# If pkgconfig found a version number, use it.
 		if(PC_Event_VERSION)
 			set(_Event_VERSION ${PC_Event_VERSION})
 		elseif(NOT CMAKE_CROSSCOMPILING)
 			try_run(_Event_CheckVersion_RESULT _Event_CheckVersion_BUILD
 				"${CMAKE_BINARY_DIR}"
 				"${CMAKE_SOURCE_DIR}/cmake/utils/EventCheckVersion.cpp"
 				CMAKE_FLAGS "-DINCLUDE_DIRECTORIES=${Event_INCLUDE_DIRS}"
 				LINK_LIBRARIES "${Event_event_LIBRARY}"
 				RUN_OUTPUT_VARIABLE _Event_VERSION
 			)
 		else()
 			# There is no way to determine the version.
 			# Let's assume the user read the doc.
 			set(_Event_VERSION 99.99.99)
 		endif()
 
 		set(Event_VERSION ${_Event_VERSION}
 			CACHE INTERNAL "Event library full version"
 		)
 	endif()
 endif()
 
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(Event
 	REQUIRED_VARS Event_INCLUDE_DIR
 	VERSION_VAR Event_VERSION
 	HANDLE_COMPONENTS
 )
diff --git a/cmake/modules/FindGMP.cmake b/cmake/modules/FindGMP.cmake
index b67f55f85..6a1cbd141 100644
--- a/cmake/modules/FindGMP.cmake
+++ b/cmake/modules/FindGMP.cmake
@@ -1,91 +1,92 @@
 # Copyright (c) 2017-2020 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #.rst
 # FindGMP
 # -------------
 #
 # Find the GNU Multiple Precision Arithmetic library. The following components
 # are available::
 #   gmp
 #
 # This will define the following variables::
 #
 #   GMP_FOUND - system has GMP lib
 #   GMP_INCLUDE_DIRS - the GMP include directories
 #   GMP_LIBRARIES - Library needed to use GMP
 #   GMP_VERSION - The library version MAJOR.MINOR.PATCH
 #   GMP_VERSION_MAJOR - The library MAJOR version number
 #   GMP_VERSION_MINOR - The library MINOR version number
 #   GMP_VERSION_PATCH - The library PATCH version number
 #
 # And the following imported target::
 #
 #   GMP::gmp
 
 include(BrewHelper)
-find_brew_prefix(BREW_HINT gmp)
+find_brew_prefix(_GMP_BREW_HINT gmp)
 
 find_path(GMP_INCLUDE_DIR
 	NAMES gmp.h
-	HINTS ${BREW_HINT}
+	HINTS ${_GMP_BREW_HINT}
+	PATH_SUFFIXES include
 )
 set(GMP_INCLUDE_DIRS "${GMP_INCLUDE_DIR}")
 mark_as_advanced(GMP_INCLUDE_DIR)
 
 if(GMP_INCLUDE_DIR)
 	# Extract version information from the gmp.h header.
 	if(NOT DEFINED GMP_VERSION)
 		# Read the version from file gmp.h into a variable.
 		file(READ "${GMP_INCLUDE_DIR}/gmp.h" _GMP_HEADER)
 
 		# Parse the version into variables.
 		string(REGEX REPLACE
 			".*__GNU_MP_VERSION[ \t]+([0-9]+).*" "\\1"
 			GMP_VERSION_MAJOR
 			"${_GMP_HEADER}"
 		)
 		string(REGEX REPLACE
 			".*__GNU_MP_VERSION_MINOR[ \t]+([0-9]+).*" "\\1"
 			GMP_VERSION_MINOR
 			"${_GMP_HEADER}"
 		)
 		string(REGEX REPLACE
 			".*__GNU_MP_VERSION_PATCHLEVEL[ \t]+([0-9]+).*" "\\1"
 			GMP_VERSION_PATCH
 			"${_GMP_HEADER}"
 		)
 
 		# Cache the result.
 		set(GMP_VERSION_MAJOR ${GMP_VERSION_MAJOR}
 			CACHE INTERNAL "GMP major version number"
 		)
 		set(GMP_VERSION_MINOR ${GMP_VERSION_MINOR}
 			CACHE INTERNAL "GMP minor version number"
 		)
 		set(GMP_VERSION_PATCH ${GMP_VERSION_PATCH}
 			CACHE INTERNAL "GMP patch version number"
 		)
 		# The actual returned/output version variable (the others can be used if
 		# needed).
 		set(GMP_VERSION
 			"${GMP_VERSION_MAJOR}.${GMP_VERSION_MINOR}.${GMP_VERSION_PATCH}"
 			CACHE INTERNAL "GMP full version"
 		)
 	endif()
 
 	include(ExternalLibraryHelper)
 	find_component(GMP gmp
 		NAMES gmp
-		HINTS ${BREW_HINT}
+		HINTS ${_GMP_BREW_HINT}
 		INCLUDE_DIRS ${GMP_INCLUDE_DIRS}
 	)
 endif()
 
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(GMP
 	REQUIRED_VARS GMP_INCLUDE_DIR
 	VERSION_VAR GMP_VERSION
 	HANDLE_COMPONENTS
 )
diff --git a/cmake/modules/FindJemalloc.cmake b/cmake/modules/FindJemalloc.cmake
index 62670d0dc..780954a59 100644
--- a/cmake/modules/FindJemalloc.cmake
+++ b/cmake/modules/FindJemalloc.cmake
@@ -1,115 +1,115 @@
 # 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.
 
 #.rst
 # FindJemalloc
 # -------------
 #
 # Find the Jemalloc library.
 #
 # This will define the following variables::
 #
 #   Jemalloc_FOUND - system has Jemalloc lib
 #   Jemalloc_INCLUDE_DIRS - the Jemalloc include directories
 #   Jemalloc_LIBRARIES - Libraries needed to use Jemalloc
 #   Jemalloc_VERSION - The library version MAJOR.MINOR.PATCH
 #
 # And the following imported target::
 #
 #   Jemalloc::jemalloc
 
 find_package(PkgConfig)
 pkg_check_modules(PC_Jemalloc QUIET libjemalloc)
 
 include(BrewHelper)
-find_brew_prefix(BREW_HINT jemalloc)
+find_brew_prefix(_Jemalloc_BREW_HINT jemalloc)
 
 find_path(Jemalloc_INCLUDE_DIR
 	NAMES jemalloc.h
 	PATHS ${PC_Jemalloc_INCLUDE_DIRS}
-	PATH_SUFFIXES jemalloc
-	HINTS ${BREW_HINT}
+	PATH_SUFFIXES include jemalloc
+	HINTS ${_Jemalloc_BREW_HINT}
 )
 
 set(Jemalloc_INCLUDE_DIRS ${Jemalloc_INCLUDE_DIR})
 mark_as_advanced(Jemalloc_INCLUDE_DIR)
 
 if(Jemalloc_INCLUDE_DIR)
 	if(NOT Jemalloc_VERSION)
 		# If pkgconfig found a version number, use it.
 		if(PC_Jemalloc_VERSION)
 			set(_Jemalloc_VERSION ${PC_Jemalloc_VERSION})
 		else()
 			# Read the version from file db.h into a variable.
 			file(READ "${Jemalloc_INCLUDE_DIR}/jemalloc.h" _Jemalloc_HEADER)
 
 			# Parse the version into variables.
 			string(REGEX REPLACE
 				".*JEMALLOC_VERSION[ \t]+\"([^\"]+)\".*" "\\1"
 				_Jemalloc_VERSION
 				"${_Jemalloc_HEADER}"
 			)
 		endif()
 
 		string(REGEX MATCH "[0-9]+\.[0-9]+\.[0-9]+" Jemalloc_VERSION "${_Jemalloc_VERSION}")
 
 		set(Jemalloc_VERSION ${Jemalloc_VERSION}
 			CACHE INTERNAL "Jemalloc library full version"
 		)
 	endif()
 
 	include(ExternalLibraryHelper)
 
 	set(THREADS_PREFER_PTHREAD_FLAG ON)
 	find_package(Threads REQUIRED)
 
 	find_component(Jemalloc jemalloc
 		NAMES jemalloc_pic jemalloc
-		HINTS "${BREW_HINT}"
+		HINTS "${_Jemalloc_BREW_HINT}"
 		INCLUDE_DIRS ${Jemalloc_INCLUDE_DIRS}
 		PATHS ${PC_Jemalloc_LIBRARY_DIRS}
 		INTERFACE_LINK_LIBRARIES "$<$<NOT:$<PLATFORM_ID:Windows>>:m>" Threads::Threads
 	)
 
 	# jemalloc might be built with or without libdl support. Check if the link
 	# succeeds without -ldl, and add the flag otherwise.
 	if(TARGET Jemalloc::jemalloc)
 		try_compile(_Jemalloc_BUILD_WITHOUT_DL
 			${CMAKE_BINARY_DIR}
 			"${CMAKE_SOURCE_DIR}/cmake/utils/CheckJemallocBuilds.c"
 			LINK_LIBRARIES Jemalloc::jemalloc
 			OUTPUT_VARIABLE _Jemalloc_BUILD_OUTPUT
 		)
 
 		if(NOT _Jemalloc_BUILD_WITHOUT_DL)
 			# The expected error is: undefined reference to `dlsym`. Search for
 			# the `dlsym` word only in the output to check the failure is
 			# related to libdl, in order to accommodate with various compilers
 			# and locales.
 			string(REGEX MATCH "dlsym" _Jemalloc_DLSYM_IN_OUTPUT "${_Jemalloc_BUILD_OUTPUT}")
 			if(_Jemalloc_DLSYM_IN_OUTPUT)
 				set_property(
 					TARGET Jemalloc::jemalloc APPEND
 					PROPERTY INTERFACE_LINK_LIBRARIES dl
 				)
 				set(_Jemalloc_NEEDS_DL TRUE)
 			else()
 				message(FATAL_ERROR "Jemalloc was found, but the configuration failed to build a simple program. Please check it is installed properly or consider disabling it. Build output: ${_Jemalloc_BUILD_OUTPUT}")
 			endif()
 		else()
 			set(_Jemalloc_NEEDS_DL FALSE)
 		endif()
 
 		if(NOT Jemalloc_FIND_QUIETLY)
 			message(STATUS "Check if jemalloc needs libdl - ${_Jemalloc_NEEDS_DL}")
 		endif()
 	endif()
 endif()
 
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(Jemalloc
 	REQUIRED_VARS Jemalloc_INCLUDE_DIR
 	VERSION_VAR Jemalloc_VERSION
 	HANDLE_COMPONENTS
 )
diff --git a/cmake/modules/FindMiniUPnPc.cmake b/cmake/modules/FindMiniUPnPc.cmake
index b6d79c093..702d50240 100644
--- a/cmake/modules/FindMiniUPnPc.cmake
+++ b/cmake/modules/FindMiniUPnPc.cmake
@@ -1,75 +1,75 @@
 # Copyright (c) 2019-2020 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #.rst
 # FindMiniUPnPc
 # -------------
 #
 # Find the MiniUPnPc library. The following
 # components are available::
 #   miniupnpc
 #
 # This will define the following variables::
 #
 #   MiniUPnPc_FOUND - system has MiniUPnPc lib
 #   MiniUPnPc_INCLUDE_DIRS - the MiniUPnPc include directories
 #   MiniUPnPc_LIBRARIES - Libraries needed to use MiniUPnPc
 #   MiniUPnPc_VERSION - The library version MAJOR.MINOR.PATCH
 #
 # And the following imported target::
 #
 #   MiniUPnPc::miniupnpc
 
 include(BrewHelper)
-find_brew_prefix(BREW_HINT miniupnpc)
+find_brew_prefix(_MiniUPnPc_BREW_HINT miniupnpc)
 
 find_package(PkgConfig)
 pkg_check_modules(PC_MiniUPnPc QUIET libqrencode)
 
 find_path(MiniUPnPc_INCLUDE_DIR
 	NAMES miniupnpc.h
-	HINTS ${BREW_HINT}
+	HINTS ${_MiniUPnPc_BREW_HINT}
 	PATHS ${PC_MiniUPnPc_INCLUDE_DIRS}
-	PATH_SUFFIXES miniupnpc
+	PATH_SUFFIXES include miniupnpc
 )
 
 set(MiniUPnPc_INCLUDE_DIRS "${MiniUPnPc_INCLUDE_DIR}")
 mark_as_advanced(MiniUPnPc_INCLUDE_DIR)
 
 if(MiniUPnPc_INCLUDE_DIR)
 	# Extract version information from the miniupnpc.h header.
 	if(NOT DEFINED MiniUPnPc_VERSION)
 		# Read the version from file miniupnpc.h into a variable.
 		file(READ "${MiniUPnPc_INCLUDE_DIR}/miniupnpc.h" _MiniUPnPc_HEADER)
 
 		# Parse the version into variable.
 		string(REGEX REPLACE
 			".*MINIUPNPC_VERSION[ \t]+\"([0-9]+\.[0-9]+(\.[0-9]+)?)\".*" "\\1"
 			MiniUPnPc_VERSION
 			"${_MiniUPnPc_HEADER}"
 		)
 
 		set(MiniUPnPc_VERSION "${MiniUPnPc_VERSION}"
 			CACHE INTERNAL "MiniUPnPc full version"
 		)
 	endif()
 
 	include(ExternalLibraryHelper)
 	find_component(MiniUPnPc miniupnpc
 		NAMES miniupnpc
-		HINTS ${BREW_HINT}
+		HINTS ${_MiniUPnPc_BREW_HINT}
 		PATHS ${PC_MiniUPnPc_LIBRARY_DIRS}
 		PATH_SUFFIXES miniupnpc
 		INCLUDE_DIRS ${MiniUPnPc_INCLUDE_DIRS}
 		INTERFACE_LINK_LIBRARIES "$<$<PLATFORM_ID:Windows>:ws2_32;iphlpapi>"
 	)
 endif()
 
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(MiniUPnPc
 	REQUIRED_VARS
 		MiniUPnPc_INCLUDE_DIR
 	VERSION_VAR MiniUPnPc_VERSION
 	HANDLE_COMPONENTS
 )
diff --git a/cmake/modules/FindQREncode.cmake b/cmake/modules/FindQREncode.cmake
index b67f8bb9c..694d953c4 100644
--- a/cmake/modules/FindQREncode.cmake
+++ b/cmake/modules/FindQREncode.cmake
@@ -1,56 +1,57 @@
 # Copyright (c) 2019-2020 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #.rst
 # FindQREncode
 # -------------
 #
 # Find the QREncode library. The following
 # components are available::
 #   qrencode
 #
 # This will define the following variables::
 #
 #   QREncode_FOUND - system has QREncode lib
 #   QREncode_INCLUDE_DIRS - the QREncode include directories
 #   QREncode_LIBRARIES - Libraries needed to use QREncode
 #
 # And the following imported target::
 #
 #   QREncode::qrencode
 
 include(BrewHelper)
-find_brew_prefix(BREW_HINT qrencode)
+find_brew_prefix(_QREncode_BREW_HINT qrencode)
 
 find_package(PkgConfig)
 pkg_check_modules(PC_QREncode QUIET libqrencode)
 
 find_path(QREncode_INCLUDE_DIR
 	NAMES qrencode.h
-	HINTS ${BREW_HINT}
+	HINTS ${_QREncode_BREW_HINT}
 	PATHS ${PC_QREncode_INCLUDE_DIRS}
+	PATH_SUFFIXES include
 )
 
 set(QREncode_INCLUDE_DIRS "${QREncode_INCLUDE_DIR}")
 mark_as_advanced(QREncode_INCLUDE_DIR)
 
 # TODO: extract a version number.
 # For now qrencode does not provide an easy way to extract a version number.
 
 if(QREncode_INCLUDE_DIR)
 	include(ExternalLibraryHelper)
 	find_component(QREncode qrencode
 		NAMES qrencode
-		HINTS ${BREW_HINT}
+		HINTS ${_QREncode_BREW_HINT}
 		PATHS ${PC_QREncode_LIBRARY_DIRS}
 		INCLUDE_DIRS ${QREncode_INCLUDE_DIRS}
 	)
 endif()
 
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(QREncode
 	REQUIRED_VARS
 		QREncode_INCLUDE_DIR
 	HANDLE_COMPONENTS
 )