diff --git a/example/Dev.tsx b/example/Dev.tsx
index f01f31c5..f7084f25 100644
--- a/example/Dev.tsx
+++ b/example/Dev.tsx
@@ -12,14 +12,7 @@ import {
 	View,
 } from 'react-native';
 import Clipboard from '@react-native-clipboard/clipboard';
-import {
-	backupAccount,
-	getAddressBalance,
-	importAccount,
-	setupLdk,
-	syncLdk,
-	updateHeader,
-} from './ldk';
+import { getAddressBalance, setupLdk, syncLdk, updateHeader } from './ldk';
 import { connectToElectrum, subscribeToHeader } from './electrum';
 import ldk from '@synonymdev/react-native-ldk/dist/ldk';
 import lm, {
@@ -31,12 +24,7 @@ import lm, {
 	TChannelUpdate,
 } from '@synonymdev/react-native-ldk';
 import { backupServerDetails, peers } from './utils/constants';
-import {
-	createNewAccount,
-	getAccount,
-	getAddress,
-	simulateStaleRestore,
-} from './utils/helpers';
+import { createNewAccount, getAccount, getAddress } from './utils/helpers';
 import RNFS from 'react-native-fs';
 
 let logSubscription: EmitterSubscription | undefined;
@@ -44,7 +32,6 @@ let paymentSubscription: EmitterSubscription | undefined;
 let onChannelSubscription: EmitterSubscription | undefined;
 let paymentFailedSubscription: EmitterSubscription | undefined;
 let paymentPathSuccess: EmitterSubscription | undefined;
-let backupSubscriptionId: string | undefined;
 
 const Dev = (): ReactElement => {
 	const [message, setMessage] = useState('...');
@@ -144,25 +131,12 @@ const Dev = (): ReactElement => {
 			);
 		}
 
-		if (!backupSubscriptionId) {
-			backupSubscriptionId = lm.subscribeToBackups((backupRes) => {
-				if (backupRes.isErr()) {
-					return alert('Backup required but failed to export account');
-				}
-
-				console.log(
-					`Backup updated for account ${backupRes.value.account.name}`,
-				);
-			});
-		}
-
 		return (): void => {
 			logSubscription && logSubscription.remove();
 			paymentSubscription && paymentSubscription.remove();
 			paymentFailedSubscription && paymentFailedSubscription.remove();
 			paymentPathSuccess && paymentPathSuccess.remove();
 			onChannelSubscription && onChannelSubscription.remove();
-			backupSubscriptionId && lm.unsubscribeFromBackups(backupSubscriptionId);
 		};
 	}, []);
 
@@ -589,50 +563,6 @@ const Dev = (): ReactElement => {
 						}}
 					/>
 
-					<Button
-						title={'Backup Current Account'}
-						onPress={async (): Promise<void> => {
-							const backupResponse = await backupAccount();
-							if (backupResponse.isErr()) {
-								setMessage(backupResponse.error.message);
-								return;
-							}
-							console.log(backupResponse.value);
-							Clipboard.setString(JSON.stringify(backupResponse.value));
-							setMessage(
-								`Backup of the following account copied to clipboard:\n${JSON.stringify(
-									backupResponse.value.account,
-								)}`,
-							);
-						}}
-					/>
-					<Button
-						title={'Import Account From Clipboard'}
-						onPress={async (): Promise<void> => {
-							setMessage('Importing Account...');
-							const clipboardBackup = await Clipboard.getString();
-							const importResponse = await importAccount(clipboardBackup);
-							if (importResponse.isErr()) {
-								setMessage(importResponse.error.message);
-								return;
-							}
-							const accountData = JSON.stringify(importResponse.value);
-							setMessage(
-								`Successfully imported the following account: ${accountData}`,
-							);
-						}}
-					/>
-					<Button
-						title={'Simulate stale backup restore'}
-						onPress={async (): Promise<void> => {
-							try {
-								await simulateStaleRestore((msg) => setMessage(msg));
-							} catch (e) {
-								setMessage(e.message);
-								return;
-							}
-						}}
-					/>
 					<Button
 						title={'Restore backup from server'}
 						onPress={async (): Promise<void> => {
diff --git a/example/ldk/index.ts b/example/ldk/index.ts
index 9e541673..5ae59654 100644
--- a/example/ldk/index.ts
+++ b/example/ldk/index.ts
@@ -11,8 +11,6 @@ import {
 import lm, {
 	DefaultTransactionDataShape,
 	defaultUserConfig,
-	TAccount,
-	TAccountBackup,
 	THeader,
 	TTransactionData,
 	TTransactionPosition,
@@ -28,9 +26,7 @@ import {
 	getAddress,
 	getNetwork,
 	ldkNetwork,
-	setAccount,
 } from '../utils/helpers';
-import { EAccount } from '../utils/types';
 import * as bitcoin from 'bitcoinjs-lib';
 
 /**
@@ -324,42 +320,3 @@ export const broadcastTransaction = async (rawTx: string): Promise<string> => {
 		return '';
 	}
 };
-
-/**
- * Used to backup a given account.
- * @param {TAccount} [account]
- * @returns {Promise<Result<string>>}
- */
-export const backupAccount = async (
-	account?: TAccount,
-): Promise<Result<TAccountBackup>> => {
-	if (!account) {
-		account = await getAccount();
-	}
-	return await lm.backupAccount({
-		account,
-	});
-};
-
-/**
- * Used to import an account using the backup JSON string or TAccountBackup object.
- * @param {string | TAccountBackup} backup
- * @returns {Promise<Result<TAccount>>}
- */
-export const importAccount = async (
-	backup: string | TAccountBackup,
-	forceCloseAllChannels = false,
-): Promise<Result<TAccount>> => {
-	const importResponse = await lm.importAccount({
-		backup,
-		overwrite: true,
-	});
-	if (importResponse.isErr()) {
-		return err(importResponse.error.message);
-	}
-	await setAccount(importResponse.value);
-	await setItem(EAccount.currentAccountKey, importResponse.value.name);
-	await setupLdk(forceCloseAllChannels);
-	await syncLdk();
-	return ok(importResponse.value);
-};
diff --git a/example/tests/lnd.ts b/example/tests/lnd.ts
index 84b1aed9..90f00b54 100644
--- a/example/tests/lnd.ts
+++ b/example/tests/lnd.ts
@@ -559,7 +559,15 @@ describe('LND', function () {
 		// - force close channel from LDK
 		// - check everything is ok
 
-		let fees = { highPriority: 3, normal: 2, background: 1, mempoolMinimum: 1 };
+		let fees = {
+			nonAnchorChannelFee: 5,
+			anchorChannelFee: 5,
+			maxAllowedNonAnchorChannelRemoteFee: 5,
+			channelCloseMinimum: 5,
+			minAllowedAnchorChannelRemoteFee: 5,
+			minAllowedNonAnchorChannelRemoteFee: 5,
+			onChainSweep: 5,
+		};
 
 		const lmStart = await lm.start({
 			...profile.getStartParams(),
@@ -656,7 +664,15 @@ describe('LND', function () {
 		);
 
 		// set height fees and restart LDK so it catches up
-		fees = { highPriority: 30, normal: 20, background: 10, mempoolMinimum: 1 };
+		fees = {
+			nonAnchorChannelFee: 30,
+			anchorChannelFee: 30,
+			maxAllowedNonAnchorChannelRemoteFee: 30,
+			channelCloseMinimum: 5,
+			minAllowedAnchorChannelRemoteFee: 5,
+			minAllowedNonAnchorChannelRemoteFee: 5,
+			onChainSweep: 30,
+		};
 		const syncRes0 = await lm.syncLdk();
 		await lm.setFees();
 		if (syncRes0.isErr()) {
diff --git a/example/tests/unit.ts b/example/tests/unit.ts
index 279f789b..9dd02f96 100644
--- a/example/tests/unit.ts
+++ b/example/tests/unit.ts
@@ -59,10 +59,13 @@ describe('Unit', function () {
 			getScriptPubKeyHistory: async () => [],
 			getFees: () => {
 				return Promise.resolve({
-					highPriority: 10,
-					normal: 5,
-					background: 2,
-					mempoolMinimum: 1,
+					nonAnchorChannelFee: 5,
+					anchorChannelFee: 5,
+					maxAllowedNonAnchorChannelRemoteFee: 5,
+					channelCloseMinimum: 5,
+					minAllowedAnchorChannelRemoteFee: 5,
+					minAllowedNonAnchorChannelRemoteFee: 5,
+					onChainSweep: 5,
 				});
 			},
 			getTransactionData: async () => ({
diff --git a/example/utils/helpers.ts b/example/utils/helpers.ts
index fb0ee1a9..bfe0bede 100644
--- a/example/utils/helpers.ts
+++ b/example/utils/helpers.ts
@@ -1,10 +1,6 @@
 import Keychain from 'react-native-keychain';
-import {
-	EEventTypes,
-	TAccount,
-	TAvailableNetworks,
-} from '@synonymdev/react-native-ldk';
-import { backupAccount, getItem, importAccount, setItem } from '../ldk';
+import { TAccount, TAvailableNetworks } from '@synonymdev/react-native-ldk';
+import { getItem, setItem } from '../ldk';
 import { EAccount } from './types';
 import { err, ok, Result } from './result';
 import { randomBytes } from 'react-native-randombytes';
@@ -15,8 +11,6 @@ import * as bip32 from 'bip32';
 import * as bip39 from 'bip39';
 import { ENetworks } from '@synonymdev/react-native-ldk/dist/utils/types';
 import networks from '@synonymdev/react-native-ldk/dist/utils/networks';
-import ldk from '@synonymdev/react-native-ldk/dist/ldk';
-import Clipboard from '@react-native-clipboard/clipboard';
 
 /**
  * Use Keychain to save LDK name & seed.
@@ -216,78 +210,3 @@ export const ldkNetwork = (network: TAvailableNetworks): ENetworks => {
 			return ENetworks.signet;
 	}
 };
-
-export const simulateStaleRestore = async (
-	onUpdate: (string) => void,
-): Promise<void> => {
-	const channels = await ldk.listChannels();
-	if (channels.isErr()) {
-		throw channels.error;
-	}
-	if (channels.value.filter((c) => c.is_usable).length === 0) {
-		throw new Error('No usable channels. Open a channel first.');
-	}
-
-	onUpdate('Backing up...');
-	const backupResponse = await backupAccount();
-	if (backupResponse.isErr()) {
-		throw backupResponse.error;
-	}
-
-	const timeoutSeconds = 30;
-	const invoice = await ldk.createPaymentRequest({
-		amountSats: 12,
-		description: 'crash test',
-		expiryDeltaSeconds: timeoutSeconds,
-	});
-	if (invoice.isErr()) {
-		throw invoice.error;
-	}
-
-	let paymentClaimed = false;
-	let paymentSubscription = ldk.onEvent(
-		EEventTypes.channel_manager_payment_claimed,
-		() => (paymentClaimed = true),
-	);
-
-	Clipboard.setString(invoice.value.to_str);
-
-	//Keep checking if we got the payment
-	for (let i = 0; i < timeoutSeconds; i++) {
-		onUpdate(
-			`Please pay invoice in clipboard to continue (${timeoutSeconds - i})...`,
-		);
-
-		if (paymentClaimed) {
-			onUpdate('Payment claimed! Testing stale restore...');
-			break;
-		}
-
-		await new Promise((resolve) => setTimeout(resolve, 1000));
-	}
-
-	paymentSubscription.remove();
-
-	if (!paymentClaimed) {
-		throw new Error('No payment claimed. Timeout out.');
-	}
-
-	onUpdate('Importing stale backup and force closing all channels...');
-
-	await new Promise((resolve) => setTimeout(resolve, 2500));
-
-	await ldk.stop();
-	const forceCloseAllChannels = true; //To test the crash restore set to false
-	const importResponse = await importAccount(
-		backupResponse.value,
-		forceCloseAllChannels,
-	);
-	if (importResponse.isErr()) {
-		throw importResponse.error;
-	}
-
-	await new Promise((resolve) => setTimeout(resolve, 2500));
-	onUpdate(
-		"If this didn't crash and you can see your claimable balance, you're good!",
-	);
-};
diff --git a/lib/android/src/main/java/com/reactnativeldk/LdkModule.kt b/lib/android/src/main/java/com/reactnativeldk/LdkModule.kt
index c27d1000..5a7af32b 100644
--- a/lib/android/src/main/java/com/reactnativeldk/LdkModule.kt
+++ b/lib/android/src/main/java/com/reactnativeldk/LdkModule.kt
@@ -19,6 +19,7 @@ import org.ldk.structs.Result_StrSecp256k1ErrorZ.Result_StrSecp256k1ErrorZ_OK
 import org.ldk.util.UInt128
 import java.io.File
 import java.net.InetSocketAddress
+import java.net.URL
 import java.nio.file.Files
 import java.nio.file.Paths
 import java.text.SimpleDateFormat
@@ -92,7 +93,8 @@ enum class LdkErrors {
     backup_check_failed,
     backup_setup_failed,
     backup_restore_failed,
-    backup_restore_failed_existing_files
+    backup_restore_failed_existing_files,
+    scorer_download_fail
 }
 
 enum class LdkCallbackResponses {
@@ -119,7 +121,9 @@ enum class LdkCallbackResponses {
     file_write_success,
     backup_client_setup_success,
     backup_restore_success,
-    backup_client_check_success
+    backup_client_check_success,
+    scorer_download_success,
+    scorer_download_skip
 }
 
 enum class LdkFileNames(val fileName: String) {
@@ -254,7 +258,41 @@ class LdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMod
     }
 
     @ReactMethod
-    fun initNetworkGraph(network: String, rapidGossipSyncUrl: String, promise: Promise) {
+    fun downloadScorer(scorerSyncUrl: String, skipHoursThreshold: Double, promise: Promise) {
+        val scorerFile = File(accountStoragePath + "/" + LdkFileNames.scorer.fileName)
+        //If old one is still recent, skip download. Else delete it.
+        if (scorerFile.exists()) {
+            val lastModifiedHours = (System.currentTimeMillis().toDouble() - scorerFile.lastModified().toDouble()) / 1000 / 60 / 60
+            if (lastModifiedHours < skipHoursThreshold) {
+                LdkEventEmitter.send(EventTypes.native_log, "Skipping scorer download. Last updated $lastModifiedHours hours ago.")
+                return handleResolve(promise, LdkCallbackResponses.scorer_download_skip)
+            }
+
+            scorerFile.delete()
+        }
+
+        Thread(Runnable {
+            val destinationFile = accountStoragePath + "/" + LdkFileNames.scorer.fileName
+
+            URL(scorerSyncUrl).downloadFile(destinationFile) { error ->
+                if (error != null) {
+                    UiThreadUtil.runOnUiThread {
+                        handleReject(promise, LdkErrors.scorer_download_fail, Error(error))
+                    }
+                    return@downloadFile
+                }
+
+                UiThreadUtil.runOnUiThread {
+                    LdkEventEmitter.send(EventTypes.native_log, "Scorer downloaded successfully.")
+                    handleResolve(promise, LdkCallbackResponses.scorer_download_success)
+                }
+                return@downloadFile
+            }
+        }).start()
+    }
+
+    @ReactMethod
+    fun initNetworkGraph(network: String, rapidGossipSyncUrl: String, skipHoursThreshold: Double, promise: Promise) {
         if (networkGraph !== null) {
             return handleReject(promise, LdkErrors.already_init)
         }
@@ -292,7 +330,7 @@ class LdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMod
         //If it's been more than 24 hours then we need to update RGS
         val timestamp = if (networkGraph!!._last_rapid_gossip_sync_timestamp is Option_u32Z.Some) (networkGraph!!._last_rapid_gossip_sync_timestamp as Option_u32Z.Some).some.toLong() else 0 // (networkGraph!!._last_rapid_gossip_sync_timestamp as Option_u32Z.Some).some
         val minutesDiffSinceLastRGS = (System.currentTimeMillis() / 1000 - timestamp) / 60
-        if (minutesDiffSinceLastRGS < 60) {
+        if (minutesDiffSinceLastRGS < (60 * skipHoursThreshold)) {
             LdkEventEmitter.send(EventTypes.native_log, "Skipping rapid gossip sync. Last updated ${minutesDiffSinceLastRGS/60} hours ago.")
             return handleResolve(promise, LdkCallbackResponses.network_graph_init_success)
         }
@@ -366,7 +404,7 @@ class LdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMod
             networkGraph!!,
             logger.logger
         ) ?: return handleReject(promise, LdkErrors.init_scorer_failed)
-
+        
         val scorer = MultiThreadedLockableScore.of(probabilisticScorer.as_Score())
 
         val scoringParams = ProbabilisticScoringDecayParameters.with_default()
diff --git a/lib/ios/Ldk.m b/lib/ios/Ldk.m
index 7c31a22b..16e22852 100644
--- a/lib/ios/Ldk.m
+++ b/lib/ios/Ldk.m
@@ -13,7 +13,6 @@ @interface RCT_EXTERN_MODULE(Ldk, NSObject)
 RCT_EXTERN_METHOD(writeToLogFile:(NSString *)line
                   resolve:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject)
-
 RCT_EXTERN_METHOD(initChainMonitor:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject)
 RCT_EXTERN_METHOD(initKeysManager:(NSString *)seed
@@ -22,8 +21,13 @@ @interface RCT_EXTERN_MODULE(Ldk, NSObject)
 RCT_EXTERN_METHOD(initUserConfig:(NSDictionary *)userConfig
                   resolve:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(downloadScorer:(NSString *)scorerSyncUrl
+                  skipHoursThreshold:(NSInteger *)skipHoursThreshold
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
 RCT_EXTERN_METHOD(initNetworkGraph:(NSString *)network
                   rapidGossipSyncUrl:(NSString *)rapidGossipSyncUrl
+                  skipHoursThreshold:(NSInteger *)skipHoursThreshold
                   resolve:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject)
 RCT_EXTERN_METHOD(initChannelManager:(NSString *)network
diff --git a/lib/ios/Ldk.swift b/lib/ios/Ldk.swift
index 63efa6e7..ff2eab73 100644
--- a/lib/ios/Ldk.swift
+++ b/lib/ios/Ldk.swift
@@ -73,6 +73,7 @@ enum LdkErrors: String {
     case backup_restore_failed = "backup_restore_failed"
     case backup_restore_failed_existing_files = "backup_restore_failed_existing_files"
     case backup_list_files_failed = "backup_list_files_failed"
+    case scorer_download_fail = "scorer_download_fail"
 }
 
 enum LdkCallbackResponses: String {
@@ -101,6 +102,8 @@ enum LdkCallbackResponses: String {
     case backup_client_setup_success = "backup_client_setup_success"
     case backup_restore_success = "backup_restore_success"
     case backup_client_check_success = "backup_client_check_success"
+    case scorer_download_success = "scorer_download_success"
+    case scorer_download_skip = "scorer_download_skip"
 }
 
 enum LdkFileNames: String {
@@ -228,7 +231,43 @@ class Ldk: NSObject {
     }
     
     @objc
-    func initNetworkGraph(_ network: NSString, rapidGossipSyncUrl: NSString, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    func downloadScorer(_ scorerSyncUrl: NSString, skipHoursThreshold: NSInteger, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        guard let accountStoragePath = Ldk.accountStoragePath else {
+            return handleReject(reject, .init_storage_path)
+        }
+        
+        let destinationFile = accountStoragePath.appendingPathComponent(LdkFileNames.scorer.rawValue)
+        
+        //If old one is still recent, skip download. Else delete it.
+        if FileManager().fileExists(atPath: destinationFile.path) {
+            let fileAttributes = try? FileManager().attributesOfItem(atPath: destinationFile.path)
+            if let creationDate = fileAttributes?[.creationDate] as? Date {
+                let currentTime = Date()
+                let timeInterval = currentTime.timeIntervalSince(creationDate)
+                let hoursPassed = timeInterval / 3600
+                
+                if hoursPassed <= Double(skipHoursThreshold) {
+                    return handleResolve(resolve, .scorer_download_skip)
+                }
+            }
+            
+            try? FileManager().removeItem(atPath: destinationFile.path)
+        }
+        
+        let url = URL(string: String(scorerSyncUrl))!
+        let task = url.downloadTask(destination: destinationFile) { error in
+            if let error = error {
+                return handleReject(reject, .scorer_download_fail, error)
+            }
+            
+            handleResolve(resolve, .scorer_download_success)
+        }
+        
+        task?.resume()
+    }
+    
+    @objc
+    func initNetworkGraph(_ network: NSString, rapidGossipSyncUrl: NSString, skipHoursThreshold: NSInteger, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
         guard networkGraph == nil else {
             return handleReject(reject, .already_init)
         }
@@ -260,6 +299,7 @@ class Ldk: NSObject {
         }
         
         print("rapidGossipSyncUrl: \(rapidGossipSyncUrl)")
+        print("accountStoragePath: \(accountStoragePath)")
         
         //Download url passed, enable rapid gossip sync
         do {
@@ -274,7 +314,7 @@ class Ldk: NSObject {
             let timestamp = networkGraph?.getLastRapidGossipSyncTimestamp() ?? 0
             let minutesDiffSinceLastRGS = (Calendar.current.dateComponents([.minute], from: Date.init(timeIntervalSince1970: TimeInterval(timestamp)), to: Date()).minute)!
             
-            guard minutesDiffSinceLastRGS > 60 else {
+            guard minutesDiffSinceLastRGS > 60 * skipHoursThreshold else {
                 LdkEventEmitter.shared.send(withEvent: .native_log, body: "Skipping rapid gossip sync. Last updated \(minutesDiffSinceLastRGS/60) hours ago.")
                 return handleResolve(resolve, .network_graph_init_success)
             }
@@ -396,9 +436,7 @@ class Ldk: NSObject {
         )
         
         do {
-            //Only restore a node if we have existing channel monitors to restore. Else we lose our UserConfig settings when restoring.
-            //TOOD remove this check in 114 which should allow passing in userConfig
-            if let channelManagerSerialized = storedChannelManager, channelMonitorsSerialized.count > 0 {
+            if let channelManagerSerialized = storedChannelManager {
                 //Restoring node
                 LdkEventEmitter.shared.send(withEvent: .native_log, body: "Restoring node from disk")
                 
@@ -442,7 +480,7 @@ class Ldk: NSObject {
         currentBlockchainTipHash = blockHash
         currentBlockchainHeight = blockHeight
         addForegroundObserver()
-                
+           
         return handleResolve(resolve, .channel_manager_init_success)
     }
     
diff --git a/lib/src/ldk.ts b/lib/src/ldk.ts
index 0397e01b..cc989e81 100644
--- a/lib/src/ldk.ts
+++ b/lib/src/ldk.ts
@@ -35,6 +35,7 @@ import {
 	TBackupServerDetails,
 	TNodeSignReq,
 	TBackedUpFileList,
+	TDownloadScorer,
 } from './utils/types';
 import { extractPaymentRequest } from './utils/helpers';
 
@@ -97,23 +98,50 @@ class LDK {
 		}
 	}
 
+	/**
+	 * Downloads a pre-populated scorer from remote server to be used on startup.
+	 * Should be called before channel manager is initialized.
+	 * @param scorerDownloadUrl
+	 * @param skipHoursThreshold
+	 */
+	async downloadScorer({
+		scorerDownloadUrl,
+		skipHoursThreshold,
+	}: TDownloadScorer): Promise<Result<string>> {
+		try {
+			const res = await NativeLDK.downloadScorer(
+				scorerDownloadUrl,
+				skipHoursThreshold ?? 3,
+			);
+			this.writeDebugToLog('downloadScorer');
+			return ok(res);
+		} catch (e) {
+			this.writeErrorToLog('downloadScorer', e);
+			return err(e);
+		}
+	}
+
 	/**
 	 * Inits the network graph from previous cache or syncs from scratch.
 	 * By passing in rapidGossipSyncUrl p2p gossip sync will be disabled in favor out rapid gossip sync.
 	 * For local regtest p2p works fine but for mainnet it is better to enable rapid gossip sync.
+	 * Use skipHoursThreshold to avoid unnecessary http calls that check if there is an update.
 	 * https://docs.rs/lightning/latest/lightning/routing/network_graph/struct.NetworkGraph.html
 	 * @param network
 	 * @param rapidGossipSyncUrl
+	 * @param skipHoursThreshold
 	 * @returns {Promise<Err<unknown> | Ok<Ok<string> | Err<string>>>}
 	 */
 	async initNetworkGraph({
 		network,
 		rapidGossipSyncUrl,
+		skipHoursThreshold,
 	}: TInitNetworkGraphReq): Promise<Result<string>> {
 		try {
 			const res = await NativeLDK.initNetworkGraph(
 				network,
 				rapidGossipSyncUrl ?? '',
+				skipHoursThreshold ?? 3, // default to 3 hours as that is the current RGS schedule.
 			);
 			this.writeDebugToLog(
 				'initNetworkGraph',
diff --git a/lib/src/lightning-manager.ts b/lib/src/lightning-manager.ts
index 29a6bc30..9a7f0411 100644
--- a/lib/src/lightning-manager.ts
+++ b/lib/src/lightning-manager.ts
@@ -148,6 +148,8 @@ class LightningManager {
 	private pendingStartPromises: Array<(result: Result<string>) => void> = [];
 	private previousAccountName: string = '';
 
+	private backupsServerSetup = false;
+
 	constructor() {
 		// Step 0: Subscribe to all events
 		ldk.onEvent(EEventTypes.native_log, (line) => {
@@ -290,10 +292,12 @@ class LightningManager {
 		broadcastTransaction,
 		network,
 		rapidGossipSyncUrl = 'https://rapidsync.lightningdevkit.org/snapshot/',
+		scorerDownloadUrl = 'https://rapidsync.lightningdevkit.org/scoring/scorer.bin',
 		forceCloseOnStartup,
 		userConfig = defaultUserConfig,
 		trustedZeroConfPeers = [],
 		backupServerDetails,
+		skipParamCheck = false,
 	}: TLdkStart): Promise<Result<string>> {
 		if (!account) {
 			return err(
@@ -328,20 +332,29 @@ class LightningManager {
 		}
 		this.isStarting = true;
 
-		// Ensure the start params function as expected.
-		const paramCheckResponse = await startParamCheck({
-			account,
-			getBestBlock,
-			getTransactionData,
-			getTransactionPosition,
-			broadcastTransaction,
-			getAddress,
-			getScriptPubKeyHistory,
-			getFees,
-			network,
-		});
-		if (paramCheckResponse.isErr()) {
-			return this.handleStartError(paramCheckResponse);
+		if (!skipParamCheck) {
+			// Ensure the start params function as expected.
+			const paramCheckResponse = await startParamCheck({
+				account,
+				getBestBlock,
+				getTransactionData,
+				getTransactionPosition,
+				broadcastTransaction,
+				getAddress,
+				getScriptPubKeyHistory,
+				getFees,
+				network,
+			});
+			if (paramCheckResponse.isErr()) {
+				return this.handleStartError(paramCheckResponse);
+			}
+		} else {
+			ldk
+				.writeToLogFile(
+					'info',
+					'Skipping start param check. Set skipParamCheck=false for debugging.',
+				)
+				.catch(console.error);
 		}
 
 		this.getBestBlock = getBestBlock;
@@ -401,73 +414,55 @@ class LightningManager {
 			}
 		}
 
-		//Setup remote backup server
-		if (backupServerDetails) {
-			const backupSetupRes = await ldk.backupSetup({
-				seed: account.seed,
-				network: this.network,
-				details: backupServerDetails,
-			});
-			if (backupSetupRes.isErr()) {
-				return this.handleStartError(err(backupSetupRes.error));
-			}
-		}
-
-		// Step 1: Initialize the FeeEstimator
-		// Lazy loaded in native code
-		// https://docs.rs/lightning/latest/lightning/chain/chaininterface/trait.FeeEstimator.html
-
-		// Step 2: Initialize the Logger
-		// Lazy loaded in native code
-		// https://docs.rs/lightning/latest/lightning/util/logger/index.html
-
-		//Switch on log levels we're interested in. All levels are false by default.
-		await ldk.setLogLevel(ELdkLogLevels.info, true);
-		await ldk.setLogLevel(ELdkLogLevels.warn, true);
-		await ldk.setLogLevel(ELdkLogLevels.error, true);
-		await ldk.setLogLevel(ELdkLogLevels.debug, true);
-
-		//TODO might not always need this one as they make the logs a little noisy
-		// await ldk.setLogLevel(ELdkLogLevels.trace, true);
-
-		// Step 3: Initialize the BroadcasterInterface
-		// Lazy loaded in native code
-		// https://docs.rs/lightning/latest/lightning/chain/chaininterface/trait.BroadcasterInterface.html
-
-		// Step 4: Initialize Persist
-		// Lazy loaded in native code
-		// https://docs.rs/lightning/latest/lightning/chain/chainmonitor/trait.Persist.html
-
-		// Step 5: Initialize the ChainMonitor (happens when we init the ChannelManager)
-
-		// Step 6: Initialize the KeysManager
-		const keysManager = await ldk.initKeysManager(this.account.seed);
-		if (keysManager.isErr()) {
-			return this.handleStartError(keysManager);
-		}
-
-		// Step 7: Read ChannelMonitors state from disk
-		// Handled in initChannelManager below
-
 		if (network !== ENetworks.mainnet) {
-			//RGS only currently working for mainnet
+			//RGS and pre-populated scorer only available for mainnet
 			rapidGossipSyncUrl = '';
+			scorerDownloadUrl = '';
+		}
+
+		//All these calls don't need to be done in any particular sequence
+		let promises: Promise<Result<string>>[] = [
+			ldk.setLogLevel(ELdkLogLevels.info, true),
+			ldk.setLogLevel(ELdkLogLevels.warn, true),
+			ldk.setLogLevel(ELdkLogLevels.error, true),
+			ldk.setLogLevel(ELdkLogLevels.debug, true),
+			// ldk.setLogLevel(ELdkLogLevels.trace, true),
+			ldk.initKeysManager(this.account.seed),
+			ldk.initNetworkGraph({
+				network,
+				rapidGossipSyncUrl,
+				skipHoursThreshold: 3,
+			}),
+			this.setFees(),
+			ldk.initUserConfig(userConfig),
+		];
+
+		if (scorerDownloadUrl) {
+			promises.push(
+				ldk.downloadScorer({
+					scorerDownloadUrl,
+					skipHoursThreshold: 3,
+				}),
+			);
 		}
 
-		// Step 11: Optional: Initialize the NetGraphMsgHandler
-		const networkGraphRes = await ldk.initNetworkGraph({
-			network,
-			rapidGossipSyncUrl,
-		});
-		if (networkGraphRes.isErr()) {
-			return this.handleStartError(networkGraphRes);
+		if (backupServerDetails) {
+			promises.push(
+				ldk.backupSetup({
+					seed: account.seed,
+					network: this.network,
+					details: backupServerDetails,
+				}),
+			);
+			this.backupsServerSetup = true;
 		}
 
-		// Step 8: Initialize the UserConfig ChannelManager
-		const confRes = await ldk.initUserConfig(userConfig);
-
-		if (confRes.isErr()) {
-			return this.handleStartError(confRes);
+		// Check for any errors before starting channel manager.
+		const results = await Promise.all(promises);
+		for (const result of results) {
+			if (result.isErr()) {
+				return this.handleStartError(result);
+			}
 		}
 
 		const channelManagerRes = await ldk.initChannelManager({
@@ -478,39 +473,18 @@ class LightningManager {
 			return this.handleStartError(channelManagerRes);
 		}
 
-		// Attempt to abandon any stored payment ids.
-		const paymentIds = await this.getLdkPaymentIds();
-		if (paymentIds.length) {
-			await Promise.all(
-				paymentIds.map(async (paymentId) => {
-					await ldk.abandonPayment(paymentId);
-					await this.removeLdkPaymentId(paymentId);
-				}),
-			);
-		}
-
-		// Set fee estimates
-		await this.setFees();
-
 		//Force close all channels on startup. Likely to recover funds after restoring from a stale backup.
 		if (forceCloseOnStartup && forceCloseOnStartup.forceClose) {
 			await ldk.forceCloseAllChannels(forceCloseOnStartup.broadcastLatestTx);
 		}
 
 		if (!forceCloseOnStartup || forceCloseOnStartup.broadcastLatestTx) {
-			// If we're force closing without broadcasting latest state don't add peers as we're likely doing this to recovery from a stale backup
-			await this.addPeers();
+			// If we're force closing without broadcasting the latest state don't add peers as we're likely doing this to recovery from a stale backup
+			this.addPeers().catch(console.error);
 		}
 
-		// Step 9: Sync ChannelMonitors and ChannelManager to chain tip
-		await this.syncLdk();
-
-		// Step 10: Give ChannelMonitors to ChainMonitor
-
-		// Step 12: Initialize the PeerManager
-		// Done with initChannelManager
-		// Step 13: Initialize networking
-		// Done with initChannelManager
+		//Can continue in the background
+		this.syncLdk().catch(console.error);
 
 		//Writes node state to log files
 		ldk.nodeStateDump().catch(console.error);
@@ -548,9 +522,9 @@ class LightningManager {
 		);
 	}
 
-	async setFees(): Promise<void> {
+	async setFees(): Promise<Result<string>> {
 		const fees = await this.getFees();
-		await ldk.updateFees(fees);
+		return await ldk.updateFees(fees);
 	}
 
 	/**
@@ -1007,7 +981,7 @@ class LightningManager {
 		overwrite?: boolean;
 	}): Promise<Result<TAccount>> => {
 		console.warn(
-			'This method is deprecated and should only be used to import accounts that were backed up with a previous async method.',
+			'importAccount() is deprecated and should only be used to import accounts that were backed up with a previous async method.',
 		);
 		if (!this.baseStoragePath) {
 			return err(
@@ -1171,6 +1145,9 @@ class LightningManager {
 		account: TAccount;
 		includeTransactionHistory?: boolean;
 	}): Promise<Result<TAccountBackup>> => {
+		console.warn(
+			'backupAccount() is deprecated and will be removed in future versions. Use remote backup server instead.',
+		);
 		if (!this.baseStoragePath) {
 			return err(
 				'baseStoragePath required for wallet persistence. Call setBaseStoragePath(path) first.',
@@ -1373,6 +1350,9 @@ class LightningManager {
 	subscribeToBackups(
 		callback: (backup: Result<TAccountBackup>) => void,
 	): string {
+		console.warn(
+			'subscribeToBackups() is deprecated, use backup server instead.',
+		);
 		this.backupSubscriptionsId++;
 		const id = `${this.backupSubscriptionsId}`;
 		this.backupSubscriptions[id] = callback;
@@ -1384,6 +1364,9 @@ class LightningManager {
 	 * @param id
 	 */
 	unsubscribeFromBackups(id: string): void {
+		console.warn(
+			'unsubscribeFromBackups() is deprecated, use backup server instead.',
+		);
 		if (this.backupSubscriptions[id]) {
 			delete this.backupSubscriptions[id];
 		}
@@ -1395,6 +1378,9 @@ class LightningManager {
 	 * @returns {Promise<void>}
 	 */
 	private async onLdkBackupEvent(): Promise<void> {
+		if (this.backupsServerSetup) {
+			return;
+		}
 		if (this.backupSubscriptionsDebounceTimer) {
 			clearTimeout(this.backupSubscriptionsDebounceTimer);
 		}
diff --git a/lib/src/utils/types.ts b/lib/src/utils/types.ts
index 650c485e..bcb83e9a 100644
--- a/lib/src/utils/types.ts
+++ b/lib/src/utils/types.ts
@@ -310,9 +310,15 @@ export type TInitChannelManagerReq = {
 	};
 };
 
+export type TDownloadScorer = {
+	scorerDownloadUrl: string;
+	skipHoursThreshold?: number;
+};
+
 export type TInitNetworkGraphReq = {
 	network: ENetworks;
 	rapidGossipSyncUrl?: string;
+	skipHoursThreshold?: number;
 };
 
 export type TChannelHandshakeConfig = {
@@ -553,10 +559,12 @@ export type TLdkStart = {
 	broadcastTransaction: TBroadcastTransaction;
 	network: ENetworks;
 	rapidGossipSyncUrl?: string;
+	scorerDownloadUrl?: string;
 	forceCloseOnStartup?: TForceCloseOnStartup;
 	userConfig?: TUserConfig;
 	trustedZeroConfPeers?: string[];
 	backupServerDetails?: TBackupServerDetails;
+	skipParamCheck?: boolean;
 };
 
 export type TGetAddress = () => Promise<string>;