diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 7e4487ac8..9ecd27cc3 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -14,7 +14,7 @@ on:
     - cron:  '0 5 * * 4'
 
 concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
+  group: "${{ github.workflow }}-${{ github.ref }}-${{ github.event_name }}"
   cancel-in-progress: true
 permissions:
   repository-projects: read
@@ -57,7 +57,7 @@ jobs:
     - name: Installation - *nix
       if: runner.os == 'Linux'
       run: |
-        python -m pip install --upgrade pip==23.0.1 wheel==0.38.4
+        python -m pip install --upgrade pip wheel
         export LD_LIBRARY_PATH=${HOME}/dependencies/lib:$LD_LIBRARY_PATH
         export TA_LIBRARY_PATH=${HOME}/dependencies/lib
         export TA_INCLUDE_PATH=${HOME}/dependencies/include
@@ -77,6 +77,17 @@ jobs:
         # Allow failure for coveralls
         coveralls || true
 
+    - name: Check for repository changes
+      run: |
+        if [ -n "$(git status --porcelain)" ]; then
+          echo "Repository is dirty, changes detected:"
+          git status
+          git diff
+          exit 1
+        else
+          echo "Repository is clean, no changes detected."
+        fi
+
     - name: Backtesting (multi)
       run: |
         cp config_examples/config_bittrex.example.json config.json
@@ -163,7 +174,7 @@ jobs:
         rm /usr/local/bin/python3.11-config || true
 
         brew install hdf5 c-blosc
-        python -m pip install --upgrade pip==23.0.1 wheel==0.38.4
+        python -m pip install --upgrade pip wheel
         export LD_LIBRARY_PATH=${HOME}/dependencies/lib:$LD_LIBRARY_PATH
         export TA_LIBRARY_PATH=${HOME}/dependencies/lib
         export TA_INCLUDE_PATH=${HOME}/dependencies/include
@@ -174,6 +185,17 @@ jobs:
       run: |
         pytest --random-order
 
+    - name: Check for repository changes
+      run: |
+        if [ -n "$(git status --porcelain)" ]; then
+          echo "Repository is dirty, changes detected:"
+          git status
+          git diff
+          exit 1
+        else
+          echo "Repository is clean, no changes detected."
+        fi
+
     - name: Backtesting
       run: |
         cp config_examples/config_bittrex.example.json config.json
@@ -237,6 +259,18 @@ jobs:
       run: |
         pytest --random-order
 
+    - name: Check for repository changes
+      run: |
+        if (git status --porcelain) {
+          Write-Host "Repository is dirty, changes detected:"
+          git status
+          git diff
+          exit 1
+        }
+        else {
+          Write-Host "Repository is clean, no changes detected."
+        }
+
     - name: Backtesting
       run: |
         cp config_examples/config_bittrex.example.json config.json
@@ -302,7 +336,7 @@ jobs:
     - name: Set up Python
       uses: actions/setup-python@v4
       with:
-        python-version: "3.10"
+        python-version: "3.11"
 
     - name: Documentation build
       run: |
@@ -352,7 +386,7 @@ jobs:
     - name: Installation - *nix
       if: runner.os == 'Linux'
       run: |
-        python -m pip install --upgrade pip==23.0.1 wheel==0.38.4
+        python -m pip install --upgrade pip wheel
         export LD_LIBRARY_PATH=${HOME}/dependencies/lib:$LD_LIBRARY_PATH
         export TA_LIBRARY_PATH=${HOME}/dependencies/lib
         export TA_INCLUDE_PATH=${HOME}/dependencies/include
@@ -425,7 +459,7 @@ jobs:
         python setup.py sdist bdist_wheel
 
     - name: Publish to PyPI (Test)
-      uses: pypa/gh-action-pypi-publish@v1.8.5
+      uses: pypa/gh-action-pypi-publish@v1.8.6
       if: (github.event_name == 'release')
       with:
         user: __token__
@@ -433,7 +467,7 @@ jobs:
         repository_url: https://test.pypi.org/legacy/
 
     - name: Publish to PyPI
-      uses: pypa/gh-action-pypi-publish@v1.8.5
+      uses: pypa/gh-action-pypi-publish@v1.8.6
       if: (github.event_name == 'release')
       with:
         user: __token__
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 0031300cd..4be298d7b 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -15,10 +15,10 @@ repos:
         additional_dependencies:
           - types-cachetools==5.3.0.5
           - types-filelock==3.2.7
-          - types-requests==2.28.11.17
+          - types-requests==2.30.0.0
           - types-tabulate==0.9.0.2
-          - types-python-dateutil==2.8.19.12
-          - SQLAlchemy==2.0.10
+          - types-python-dateutil==2.8.19.13
+          - SQLAlchemy==2.0.15
         # stages: [push]
 
   - repo: https://github.com/pycqa/isort
@@ -30,7 +30,7 @@ repos:
 
   - repo: https://github.com/charliermarsh/ruff-pre-commit
     # Ruff version.
-    rev: 'v0.0.255'
+    rev: 'v0.0.263'
     hooks:
       - id: ruff
 
diff --git a/Dockerfile b/Dockerfile
index ee8b3f0a8..d3890a25b 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -25,7 +25,7 @@ FROM base as python-deps
 RUN  apt-get update \
   && apt-get -y install build-essential libssl-dev git libffi-dev libgfortran5 pkg-config cmake gcc \
   && apt-get clean \
-  && pip install --upgrade pip==23.0.1 wheel==0.38.4
+  && pip install --upgrade pip wheel
 
 # Install TA-lib
 COPY build_helpers/* /tmp/
diff --git a/build_helpers/install_windows.ps1 b/build_helpers/install_windows.ps1
index 3e7df5dfc..2fc21d317 100644
--- a/build_helpers/install_windows.ps1
+++ b/build_helpers/install_windows.ps1
@@ -1,7 +1,7 @@
 # Downloads don't work automatically, since the URL is regenerated via javascript.
 # Downloaded from https://www.lfd.uci.edu/~gohlke/pythonlibs/#ta-lib
 
-python -m pip install --upgrade pip==23.0.1 wheel==0.38.4
+python -m pip install --upgrade pip wheel
 
 $pyv = python -c "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')"
 
diff --git a/build_helpers/pyarrow-11.0.0-cp39-cp39-linux_armv7l.whl b/build_helpers/pyarrow-12.0.0-cp39-cp39-linux_armv7l.whl
similarity index 59%
rename from build_helpers/pyarrow-11.0.0-cp39-cp39-linux_armv7l.whl
rename to build_helpers/pyarrow-12.0.0-cp39-cp39-linux_armv7l.whl
index a7ad80bdf..2a8d1ff51 100644
Binary files a/build_helpers/pyarrow-11.0.0-cp39-cp39-linux_armv7l.whl and b/build_helpers/pyarrow-12.0.0-cp39-cp39-linux_armv7l.whl differ
diff --git a/docker-compose.yml b/docker-compose.yml
index 445fbaea0..3b6f45bfc 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -6,6 +6,15 @@ services:
     # image: freqtradeorg/freqtrade:develop
     # Use plotting image
     # image: freqtradeorg/freqtrade:develop_plot
+    # # Enable GPU Image and GPU Resources (only relevant for freqAI)
+    # # Make sure to uncomment the whole deploy section
+    # deploy:
+    #   resources:
+    #     reservations:
+    #       devices:
+    #         - driver: nvidia
+    #           count: 1
+    #           capabilities: [gpu]
     # Build step - only needed when additional dependencies are needed
     # build:
     #   context: .
@@ -16,7 +25,7 @@ services:
       - "./user_data:/freqtrade/user_data"
     # Expose api on port 8080 (localhost only)
     # Please read the https://www.freqtrade.io/en/stable/rest-api/ documentation
-    # before enabling this.
+    # for more information.
     ports:
       - "127.0.0.1:8080:8080"
     # Default command used when running `docker compose up`
diff --git a/docker/docker-compose-freqai.yml b/docker/docker-compose-freqai.yml
new file mode 100644
index 000000000..6edf41238
--- /dev/null
+++ b/docker/docker-compose-freqai.yml
@@ -0,0 +1,36 @@
+---
+version: '3'
+services:
+  freqtrade:
+    image: freqtradeorg/freqtrade:stable_freqaitorch
+    # # Enable GPU Image and GPU Resources
+    # # Make sure to uncomment the whole deploy section
+    # deploy:
+    #   resources:
+    #     reservations:
+    #       devices:
+    #         - driver: nvidia
+    #           count: 1
+    #           capabilities: [gpu]
+
+    # Build step - only needed when additional dependencies are needed
+    # build:
+    #   context: .
+    #   dockerfile: "./docker/Dockerfile.custom"
+    restart: unless-stopped
+    container_name: freqtrade
+    volumes:
+      - "./user_data:/freqtrade/user_data"
+    # Expose api on port 8080 (localhost only)
+    # Please read the https://www.freqtrade.io/en/stable/rest-api/ documentation
+    # for more information.
+    ports:
+      - "127.0.0.1:8080:8080"
+    # Default command used when running `docker compose up`
+    command: >
+      trade
+      --logfile /freqtrade/user_data/logs/freqtrade.log
+      --db-url sqlite:////freqtrade/user_data/tradesv3.sqlite
+      --config /freqtrade/user_data/config.json
+      --freqai-model XGBoostClassifier
+      --strategy SampleStrategy
diff --git a/docs/advanced-backtesting.md b/docs/advanced-backtesting.md
index be9099df8..b587c4157 100644
--- a/docs/advanced-backtesting.md
+++ b/docs/advanced-backtesting.md
@@ -29,7 +29,7 @@ If all goes well, you should now see a `backtest-result-{timestamp}_signals.pkl`
 `user_data/backtest_results` folder.
 
 To analyze the entry/exit tags, we now need to use the `freqtrade backtesting-analysis` command
-with `--analysis-groups` option provided with space-separated arguments (default `0 1 2`):
+with `--analysis-groups` option provided with space-separated arguments:
 
 ``` bash
 freqtrade backtesting-analysis -c <config.json> --analysis-groups 0 1 2 3 4 5
@@ -39,6 +39,7 @@ This command will read from the last backtesting results. The `--analysis-groups
 used to specify the various tabular outputs showing the profit fo each group or trade,
 ranging from the simplest (0) to the most detailed per pair, per buy and per sell tag (4):
 
+* 0: overall winrate and profit summary by enter_tag
 * 1: profit summaries grouped by enter_tag
 * 2: profit summaries grouped by enter_tag and exit_tag
 * 3: profit summaries grouped by pair and enter_tag
@@ -115,3 +116,38 @@ For example, if your backtest timerange was `20220101-20221231` but you only wan
 ```bash
 freqtrade backtesting-analysis -c <config.json> --timerange 20220101-20220201
 ```
+
+### Printing out rejected signals
+
+Use the `--rejected-signals` option to print out rejected signals.
+
+```bash
+freqtrade backtesting-analysis -c <config.json> --rejected-signals
+```
+
+### Writing tables to CSV
+
+Some of the tabular outputs can become large, so printing them out to the terminal is not preferable.
+Use the `--analysis-to-csv` option to disable printing out of tables to standard out and write them to CSV files.
+
+```bash
+freqtrade backtesting-analysis -c <config.json> --analysis-to-csv
+```
+
+By default this will write one file per output table you specified in the `backtesting-analysis` command, e.g.
+
+```bash
+freqtrade backtesting-analysis -c <config.json> --analysis-to-csv --rejected-signals --analysis-groups 0 1
+```
+
+This will write to `user_data/backtest_results`:
+
+* rejected_signals.csv
+* group_0.csv
+* group_1.csv
+
+To override where the files will be written, also specify the `--analysis-csv-path` option.
+
+```bash
+freqtrade backtesting-analysis -c <config.json> --analysis-to-csv --analysis-csv-path another/data/path/
+```
diff --git a/docs/developer.md b/docs/developer.md
index 1bc75551f..2782f0117 100644
--- a/docs/developer.md
+++ b/docs/developer.md
@@ -327,18 +327,18 @@ To check how the new exchange behaves, you can use the following snippet:
 
 ``` python
 import ccxt
-from datetime import datetime
+from datetime import datetime, timezone
 from freqtrade.data.converter import ohlcv_to_dataframe
-ct = ccxt.binance()
+ct = ccxt.binance()  # Use the exchange you're testing
 timeframe = "1d"
-pair = "XLM/BTC"  # Make sure to use a pair that exists on that exchange!
+pair = "BTC/USDT"  # Make sure to use a pair that exists on that exchange!
 raw = ct.fetch_ohlcv(pair, timeframe=timeframe)
 
 # convert to dataframe
 df1 = ohlcv_to_dataframe(raw, timeframe, pair=pair, drop_incomplete=False)
 
 print(df1.tail(1))
-print(datetime.utcnow())
+print(datetime.now(timezone.utc))
 ```
 
 ``` output
diff --git a/docs/freqai-configuration.md b/docs/freqai-configuration.md
index e7aca20be..43c9fee75 100644
--- a/docs/freqai-configuration.md
+++ b/docs/freqai-configuration.md
@@ -248,9 +248,11 @@ The easiest way to quickly run a pytorch model is with the following command (fo
 freqtrade trade --config config_examples/config_freqai.example.json --strategy FreqaiExampleStrategy --freqaimodel PyTorchMLPRegressor --strategy-path freqtrade/templates 
 ```
 
-!!! note "Installation/docker"
+!!! Note "Installation/docker"
     The PyTorch module requires large packages such as `torch`, which should be explicitly requested during `./setup.sh -i` by answering "y" to the question "Do you also want dependencies for freqai-rl or PyTorch (~700mb additional space required) [y/N]?".
     Users who prefer docker should ensure they use the docker image appended with `_freqaitorch`.
+    We do provide an explicit docker-compose file for this in `docker/docker-compose-freqai.yml` - which can be used via `docker compose -f docker/docker-compose-freqai.yml run ...` - or can be copied to replace the original docker file.
+    This docker-compose file also contains a (disabled) section to enable GPU resources within docker containers. This obviously assumes the system has GPU resources available.
 
 ### Structure
 
@@ -395,3 +397,21 @@ Here we create a `PyTorchMLPRegressor` class that implements the `fit` method. T
         return dataframe
     ```
     To see a full example, you can refer to the [classifier test strategy class](https://github.com/freqtrade/freqtrade/blob/develop/tests/strategy/strats/freqai_test_classifier.py).
+
+
+#### Improving performance with `torch.compile()`
+
+Torch provides a `torch.compile()` method that can be used to improve performance for specific GPU hardware. More details can be found [here](https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html). In brief, you simply wrap your `model` in `torch.compile()`:
+
+
+```python
+        model = PyTorchMLPModel(
+            input_dim=n_features,
+            output_dim=1,
+            **self.model_kwargs
+        )
+        model.to(self.device)
+        model = torch.compile(model)
+```
+
+Then proceed to use the model as normal. Keep in mind that doing this will remove eager execution, which means errors and tracebacks will not be informative.
diff --git a/docs/freqai-parameter-table.md b/docs/freqai-parameter-table.md
index 1487b92c2..cc92c2457 100644
--- a/docs/freqai-parameter-table.md
+++ b/docs/freqai-parameter-table.md
@@ -18,9 +18,10 @@ Mandatory parameters are marked as **Required** and have to be set in one of the
 | `purge_old_models` | Number of models to keep on disk (not relevant to backtesting). Default is 2, which means that dry/live runs will keep the latest 2 models on disk. Setting to 0 keeps all models. This parameter also accepts a boolean to maintain backwards compatibility. <br> **Datatype:** Integer. <br> Default: `2`.
 | `save_backtest_models` | Save models to disk when running backtesting. Backtesting operates most efficiently by saving the prediction data and reusing them directly for subsequent runs (when you wish to tune entry/exit parameters). Saving backtesting models to disk also allows to use the same model files for starting a dry/live instance with the same model `identifier`. <br> **Datatype:** Boolean. <br> Default: `False` (no models are saved).
 | `fit_live_predictions_candles` | Number of historical candles to use for computing target (label) statistics from prediction data, instead of from the training dataset (more information can be found [here](freqai-configuration.md#creating-a-dynamic-target-threshold)). <br> **Datatype:** Positive integer.
-| `continual_learning` | Use the final state of the most recently trained model as starting point for the new model, allowing for incremental learning (more information can be found [here](freqai-running.md#continual-learning)). <br> **Datatype:** Boolean. <br> Default: `False`.
+| `continual_learning` | Use the final state of the most recently trained model as starting point for the new model, allowing for incremental learning (more information can be found [here](freqai-running.md#continual-learning)). Beware that this is currently a naive approach to incremental learning, and it has a high probability of overfitting/getting stuck in local minima while the market moves away from your model. We have the connections here primarily for experimental purposes and so that it is ready for more mature approaches to continual learning in chaotic systems like the crypto market. <br> **Datatype:** Boolean. <br> Default: `False`.
 | `write_metrics_to_disk` | Collect train timings, inference timings and cpu usage in json file. <br> **Datatype:** Boolean. <br> Default: `False`
 | `data_kitchen_thread_count` | <br> Designate the number of threads you want to use for data processing (outlier methods, normalization, etc.). This has no impact on the number of threads used for training. If user does not set it (default), FreqAI will use max number of threads - 2 (leaving 1 physical core available for Freqtrade bot and FreqUI) <br> **Datatype:** Positive integer.
+| `activate_tensorboard` | <br> Indicate whether or not to activate tensorboard for the tensorboard enabled modules (currently Reinforcment Learning, XGBoost, Catboost, and PyTorch). Tensorboard needs Torch installed, which means you will need the torch/RL docker image or you need to answer "yes" to the install question about whether or not you wish to install Torch. <br> **Datatype:** Boolean. <br> Default: `True`.
 
 ### Feature parameters
 
@@ -114,5 +115,5 @@ Mandatory parameters are marked as **Required** and have to be set in one of the
 |------------|-------------|
 |  |  **Extraneous parameters**
 | `freqai.keras` | If the selected model makes use of Keras (typical for TensorFlow-based prediction models), this flag needs to be activated so that the model save/loading follows Keras standards. <br> **Datatype:** Boolean. <br> Default: `False`.
-| `freqai.conv_width` | The width of a convolutional neural network input tensor. This replaces the need for shifting candles (`include_shifted_candles`) by feeding in historical data points as the second dimension of the tensor. Technically, this parameter can also be used for regressors, but it only adds computational overhead and does not change the model training/prediction. <br> **Datatype:** Integer. <br> Default: `2`.
+| `freqai.conv_width` | The width of a neural network input tensor. This replaces the need for shifting candles (`include_shifted_candles`) by feeding in historical data points as the second dimension of the tensor. Technically, this parameter can also be used for regressors, but it only adds computational overhead and does not change the model training/prediction. <br> **Datatype:** Integer. <br> Default: `2`.
 | `freqai.reduce_df_footprint` | Recast all numeric columns to float32/int32, with the objective of reducing ram/disk usage and decreasing train/inference timing. This parameter is set in the main level of the Freqtrade configuration file (not inside FreqAI). <br> **Datatype:** Boolean. <br> Default: `False`.
diff --git a/docs/freqai-reinforcement-learning.md b/docs/freqai-reinforcement-learning.md
index 962827348..1c95409ae 100644
--- a/docs/freqai-reinforcement-learning.md
+++ b/docs/freqai-reinforcement-learning.md
@@ -135,92 +135,104 @@ Parameter details can be found [here](freqai-parameter-table.md), but in general
 
 ## Creating a custom reward function
 
-As you begin to modify the strategy and the prediction model, you will quickly realize some important differences between the Reinforcement Learner and the Regressors/Classifiers. Firstly, the strategy does not set a target value (no labels!). Instead, you set the `calculate_reward()` function inside the `MyRLEnv` class (see below). A default `calculate_reward()` is provided inside `prediction_models/ReinforcementLearner.py` to demonstrate the necessary building blocks for creating rewards, but users are encouraged to create their own custom reinforcement learning model class (see below) and save it to `user_data/freqaimodels`. It is inside the `calculate_reward()` where creative theories about the market can be expressed. For example, you can reward your agent when it makes a winning trade, and penalize the agent when it makes a losing trade. Or perhaps, you wish to reward the agent for entering trades, and penalize the agent for sitting in trades too long. Below we show examples of how these rewards are all calculated:
+!!! danger "Not for production"
+    Warning!
+    The reward function provided with the Freqtrade source code is a showcase of functionality designed to show/test as many possible environment control features as possible. It is also designed to run quickly on small computers. This is a benchmark, it is *not* for live production. Please beware that you will need to create your own custom_reward() function or use a template built by other users outside of the Freqtrade source code.
+
+As you begin to modify the strategy and the prediction model, you will quickly realize some important differences between the Reinforcement Learner and the Regressors/Classifiers. Firstly, the strategy does not set a target value (no labels!). Instead, you set the `calculate_reward()` function inside the `MyRLEnv` class (see below). A default `calculate_reward()` is provided inside `prediction_models/ReinforcementLearner.py` to demonstrate the necessary building blocks for creating rewards, but this is *not* designed for production. Users *must* create their own custom reinforcement learning model class or use a pre-built one from outside the Freqtrade source code and save it to `user_data/freqaimodels`. It is inside the `calculate_reward()` where creative theories about the market can be expressed. For example, you can reward your agent when it makes a winning trade, and penalize the agent when it makes a losing trade. Or perhaps, you wish to reward the agent for entering trades, and penalize the agent for sitting in trades too long. Below we show examples of how these rewards are all calculated:
+
+!!! note "Hint"
+    The best reward functions are ones that are continuously differentiable, and well scaled. In other words, adding a single large negative penalty to a rare event is not a good idea, and the neural net will not be able to learn that function. Instead, it is better to add a small negative penalty to a common event. This will help the agent learn faster. Not only this, but you can help improve the continuity of your rewards/penalties by having them scale with severity according to some linear/exponential functions. In other words, you'd slowly scale the penalty as the duration of the trade increases. This is better than a single large penalty occuring at a single point in time.
 
 ```python
-    from freqtrade.freqai.prediction_models.ReinforcementLearner import ReinforcementLearner
-    from freqtrade.freqai.RL.Base5ActionRLEnv import Actions, Base5ActionRLEnv, Positions
+from freqtrade.freqai.prediction_models.ReinforcementLearner import ReinforcementLearner
+from freqtrade.freqai.RL.Base5ActionRLEnv import Actions, Base5ActionRLEnv, Positions
 
 
-    class MyCoolRLModel(ReinforcementLearner):
+class MyCoolRLModel(ReinforcementLearner):
+    """
+    User created RL prediction model.
+
+    Save this file to `freqtrade/user_data/freqaimodels`
+
+    then use it with:
+
+    freqtrade trade --freqaimodel MyCoolRLModel --config config.json --strategy SomeCoolStrat
+
+    Here the users can override any of the functions
+    available in the `IFreqaiModel` inheritance tree. Most importantly for RL, this
+    is where the user overrides `MyRLEnv` (see below), to define custom
+    `calculate_reward()` function, or to override any other parts of the environment.
+
+    This class also allows users to override any other part of the IFreqaiModel tree.
+    For example, the user can override `def fit()` or `def train()` or `def predict()`
+    to take fine-tuned control over these processes.
+
+    Another common override may be `def data_cleaning_predict()` where the user can
+    take fine-tuned control over the data handling pipeline.
+    """
+    class MyRLEnv(Base5ActionRLEnv):
         """
-        User created RL prediction model.
+        User made custom environment. This class inherits from BaseEnvironment and gym.env.
+        Users can override any functions from those parent classes. Here is an example
+        of a user customized `calculate_reward()` function.
 
-        Save this file to `freqtrade/user_data/freqaimodels`
-
-        then use it with:
-
-        freqtrade trade --freqaimodel MyCoolRLModel --config config.json --strategy SomeCoolStrat
-
-        Here the users can override any of the functions
-        available in the `IFreqaiModel` inheritance tree. Most importantly for RL, this
-        is where the user overrides `MyRLEnv` (see below), to define custom
-        `calculate_reward()` function, or to override any other parts of the environment.
-
-        This class also allows users to override any other part of the IFreqaiModel tree.
-        For example, the user can override `def fit()` or `def train()` or `def predict()`
-        to take fine-tuned control over these processes.
-
-        Another common override may be `def data_cleaning_predict()` where the user can
-        take fine-tuned control over the data handling pipeline.
+        Warning!
+        This is function is a showcase of functionality designed to show as many possible
+        environment control features as possible. It is also designed to run quickly
+        on small computers. This is a benchmark, it is *not* for live production.
         """
-        class MyRLEnv(Base5ActionRLEnv):
-            """
-            User made custom environment. This class inherits from BaseEnvironment and gym.env.
-            Users can override any functions from those parent classes. Here is an example
-            of a user customized `calculate_reward()` function.
-            """
-            def calculate_reward(self, action: int) -> float:
-                # first, penalize if the action is not valid
-                if not self._is_valid(action):
-                    return -2
-                pnl = self.get_unrealized_profit()
+        def calculate_reward(self, action: int) -> float:
+            # first, penalize if the action is not valid
+            if not self._is_valid(action):
+                return -2
+            pnl = self.get_unrealized_profit()
 
-                factor = 100
+            factor = 100
 
-                pair = self.pair.replace(':', '')
+            pair = self.pair.replace(':', '')
 
-                # you can use feature values from dataframe
-                # Assumes the shifted RSI indicator has been generated in the strategy.
-                rsi_now = self.raw_features[f"%-rsi-period_10_shift-1_{pair}_"
-                                f"{self.config['timeframe']}"].iloc[self._current_tick]
+            # you can use feature values from dataframe
+            # Assumes the shifted RSI indicator has been generated in the strategy.
+            rsi_now = self.raw_features[f"%-rsi-period_10_shift-1_{pair}_"
+                            f"{self.config['timeframe']}"].iloc[self._current_tick]
 
-                # reward agent for entering trades
-                if (action in (Actions.Long_enter.value, Actions.Short_enter.value)
-                        and self._position == Positions.Neutral):
-                    if rsi_now < 40:
-                        factor = 40 / rsi_now
-                    else:
-                        factor = 1
-                    return 25 * factor
+            # reward agent for entering trades
+            if (action in (Actions.Long_enter.value, Actions.Short_enter.value)
+                    and self._position == Positions.Neutral):
+                if rsi_now < 40:
+                    factor = 40 / rsi_now
+                else:
+                    factor = 1
+                return 25 * factor
 
-                # discourage agent from not entering trades
-                if action == Actions.Neutral.value and self._position == Positions.Neutral:
-                    return -1
-                max_trade_duration = self.rl_config.get('max_trade_duration_candles', 300)
-                trade_duration = self._current_tick - self._last_trade_tick
-                if trade_duration <= max_trade_duration:
-                    factor *= 1.5
-                elif trade_duration > max_trade_duration:
-                    factor *= 0.5
-                # discourage sitting in position
-                if self._position in (Positions.Short, Positions.Long) and \
-                action == Actions.Neutral.value:
-                    return -1 * trade_duration / max_trade_duration
-                # close long
-                if action == Actions.Long_exit.value and self._position == Positions.Long:
-                    if pnl > self.profit_aim * self.rr:
-                        factor *= self.rl_config['model_reward_parameters'].get('win_reward_factor', 2)
-                    return float(pnl * factor)
-                # close short
-                if action == Actions.Short_exit.value and self._position == Positions.Short:
-                    if pnl > self.profit_aim * self.rr:
-                        factor *= self.rl_config['model_reward_parameters'].get('win_reward_factor', 2)
-                    return float(pnl * factor)
-                return 0.
+            # discourage agent from not entering trades
+            if action == Actions.Neutral.value and self._position == Positions.Neutral:
+                return -1
+            max_trade_duration = self.rl_config.get('max_trade_duration_candles', 300)
+            trade_duration = self._current_tick - self._last_trade_tick
+            if trade_duration <= max_trade_duration:
+                factor *= 1.5
+            elif trade_duration > max_trade_duration:
+                factor *= 0.5
+            # discourage sitting in position
+            if self._position in (Positions.Short, Positions.Long) and \
+            action == Actions.Neutral.value:
+                return -1 * trade_duration / max_trade_duration
+            # close long
+            if action == Actions.Long_exit.value and self._position == Positions.Long:
+                if pnl > self.profit_aim * self.rr:
+                    factor *= self.rl_config['model_reward_parameters'].get('win_reward_factor', 2)
+                return float(pnl * factor)
+            # close short
+            if action == Actions.Short_exit.value and self._position == Positions.Short:
+                if pnl > self.profit_aim * self.rr:
+                    factor *= self.rl_config['model_reward_parameters'].get('win_reward_factor', 2)
+                return float(pnl * factor)
+            return 0.
 ```
 
-### Using Tensorboard
+## Using Tensorboard
 
 Reinforcement Learning models benefit from tracking training metrics. FreqAI has integrated Tensorboard to allow users to track training and evaluation performance across all coins and across all retrainings. Tensorboard is activated via the following command:
 
@@ -233,32 +245,30 @@ where `unique-id` is the `identifier` set in the `freqai` configuration file. Th
 
 ![tensorboard](assets/tensorboard.jpg)
 
-
-### Custom logging
+## Custom logging
 
 FreqAI also provides a built in episodic summary logger called `self.tensorboard_log` for adding custom information to the Tensorboard log. By default, this function is already called once per step inside the environment to record the agent actions. All values accumulated for all steps in a single episode are reported at the conclusion of each episode, followed by a full reset of all metrics to 0 in preparation for the subsequent episode.
 
-
 `self.tensorboard_log` can also be used anywhere inside the environment, for example, it can be added to the `calculate_reward` function to collect more detailed information about how often various parts of the reward were called:
 
-```py
-        class MyRLEnv(Base5ActionRLEnv):
-            """
-            User made custom environment. This class inherits from BaseEnvironment and gym.env.
-            Users can override any functions from those parent classes. Here is an example
-            of a user customized `calculate_reward()` function.
-            """
-            def calculate_reward(self, action: int) -> float:
-                if not self._is_valid(action):
-                    self.tensorboard_log("invalid")
-                    return -2
+```python
+    class MyRLEnv(Base5ActionRLEnv):
+        """
+        User made custom environment. This class inherits from BaseEnvironment and gym.env.
+        Users can override any functions from those parent classes. Here is an example
+        of a user customized `calculate_reward()` function.
+        """
+        def calculate_reward(self, action: int) -> float:
+            if not self._is_valid(action):
+                self.tensorboard_log("invalid")
+                return -2
 
 ```
 
 !!! Note
     The `self.tensorboard_log()` function is designed for tracking incremented objects only i.e. events, actions inside the training environment. If the event of interest is a float, the float can be passed as the second argument e.g. `self.tensorboard_log("float_metric1", 0.23)`. In this case the metric values are not incremented.
 
-### Choosing a base environment
+## Choosing a base environment
 
 FreqAI provides three base environments, `Base3ActionRLEnvironment`, `Base4ActionEnvironment` and `Base5ActionEnvironment`. As the names imply, the environments are customized for agents that can select from 3, 4 or 5 actions. The `Base3ActionEnvironment` is the simplest, the agent can select from hold, long, or short. This environment can also be used for long-only bots (it automatically follows the `can_short` flag from the strategy), where long is the enter condition and short is the exit condition. Meanwhile, in the `Base4ActionEnvironment`, the agent can enter long, enter short, hold neutral, or exit position. Finally, in the `Base5ActionEnvironment`, the agent has the same actions as Base4, but instead of a single exit action, it separates exit long and exit short. The main changes stemming from the environment selection include:
 
diff --git a/docs/freqai-running.md b/docs/freqai-running.md
index f3ccc546f..55f302d40 100644
--- a/docs/freqai-running.md
+++ b/docs/freqai-running.md
@@ -131,6 +131,9 @@ You can choose to adopt a continual learning scheme by setting `"continual_learn
 ???+ danger "Continual learning enforces a constant parameter space"
     Since `continual_learning` means that the model parameter space *cannot* change between trainings, `principal_component_analysis` is automatically disabled when `continual_learning` is enabled. Hint: PCA changes the parameter space and the number of features, learn more about PCA [here](freqai-feature-engineering.md#data-dimensionality-reduction-with-principal-component-analysis).
 
+???+ danger "Experimental functionality"
+    Beware that this is currently a naive approach to incremental learning, and it has a high probability of overfitting/getting stuck in local minima while the market moves away from your model. We have the mechanics available in FreqAI primarily for experimental purposes and so that it is ready for more mature approaches to continual learning in chaotic systems like the crypto market.
+
 ## Hyperopt
 
 You can hyperopt using the same command as for [typical Freqtrade hyperopt](hyperopt.md):
@@ -158,7 +161,14 @@ This specific hyperopt would help you understand the appropriate `DI_values` for
 
 ## Using Tensorboard
 
-CatBoost models benefit from tracking training metrics via Tensorboard. You can take advantage of the FreqAI integration to track training and evaluation performance across all coins and across all retrainings. Tensorboard is activated via the following command:
+!!! note "Availability"
+    FreqAI includes tensorboard for a variety of models, including XGBoost, all PyTorch models, Reinforcement Learning, and Catboost. If you would like to see Tensorboard integrated into another model type, please open an issue on the [Freqtrade GitHub](https://github.com/freqtrade/freqtrade/issues)
+
+!!! danger "Requirements"
+    Tensorboard logging requires the FreqAI torch installation/docker image.
+
+
+The easiest way to use tensorboard is to ensure `freqai.activate_tensorboard` is set to `True` (default setting) in your configuration file, run FreqAI, then open a separate shell and run:
 
 ```bash
 cd freqtrade
@@ -168,3 +178,7 @@ tensorboard --logdir user_data/models/unique-id
 where `unique-id` is the `identifier` set in the `freqai` configuration file. This command must be run in a separate shell if you wish to view the output in your browser at 127.0.0.1:6060 (6060 is the default port used by Tensorboard).
 
 ![tensorboard](assets/tensorboard.jpg)
+
+
+!!! note "Deactivate for improved performance"
+    Tensorboard logging can slow down training and should be deactivated for production use.
diff --git a/docs/freqai.md b/docs/freqai.md
index ef8efb840..3c4f47212 100644
--- a/docs/freqai.md
+++ b/docs/freqai.md
@@ -32,7 +32,10 @@ The easiest way to quickly test FreqAI is to run it in dry mode with the followi
 freqtrade trade --config config_examples/config_freqai.example.json --strategy FreqaiExampleStrategy --freqaimodel LightGBMRegressor --strategy-path freqtrade/templates
 ```
 
-You will see the boot-up process of automatic data downloading, followed by simultaneous training and trading.
+You will see the boot-up process of automatic data downloading, followed by simultaneous training and trading. 
+
+!!! danger "Not for production"
+    The example strategy provided with the Freqtrade source code is designed for showcasing/testing a wide variety of FreqAI features. It is also designed to run on small computers so that it can be used as a benchmark between developers and users. It is *not* designed to be run in production.
 
 An example strategy, prediction model, and config to use as a starting points can be found in
 `freqtrade/templates/FreqaiExampleStrategy.py`, `freqtrade/freqai/prediction_models/LightGBMRegressor.py`, and
@@ -69,16 +72,15 @@ pip install -r requirements-freqai.txt
 ```
 
 !!! Note
-    Catboost will not be installed on arm devices (raspberry, Mac M1, ARM based VPS, ...), since it does not provide wheels for this platform.
-
-!!! Note "python 3.11"
-    Some dependencies (Catboost, Torch) currently don't support python 3.11. Freqtrade therefore only supports python 3.10 for these models/dependencies.
-    Tests involving these dependencies are skipped on 3.11.
+    Catboost will not be installed on low-powered arm devices (raspberry), since it does not provide wheels for this platform.
 
 ### Usage with docker
 
 If you are using docker, a dedicated tag with FreqAI dependencies is available as `:freqai`. As such - you can replace the image line in your docker compose file with `image: freqtradeorg/freqtrade:develop_freqai`. This image contains the regular FreqAI dependencies. Similar to native installs, Catboost will not be available on ARM based devices.
 
+!!! note "docker-compose-freqai.yml"
+   We do provide an explicit docker-compose file for this in `docker/docker-compose-freqai.yml` - which can be used via `docker compose -f docker/docker-compose-freqai.yml run ...` - or can be copied to replace the original docker file. This docker-compose file also contains a (disabled) section to enable GPU resources within docker containers. This obviously assumes the system has GPU resources available.
+
 ### FreqAI position in open-source machine learning landscape
 
 Forecasting chaotic time-series based systems, such as equity/cryptocurrency markets, requires a broad set of tools geared toward testing a wide range of hypotheses. Fortunately, a recent maturation of robust machine learning libraries (e.g. `scikit-learn`) has opened up a wide range of research possibilities. Scientists from a diverse range of fields can now easily prototype their studies on an abundance of established machine learning algorithms. Similarly, these user-friendly libraries enable "citzen scientists" to use their basic Python skills for data exploration. However, leveraging these machine learning libraries on historical and live chaotic data sources can be logistically difficult and expensive. Additionally, robust data collection, storage, and handling presents a disparate challenge. [`FreqAI`](#freqai) aims to provide a generalized and extensible open-sourced framework geared toward live deployments of adaptive modeling for market forecasting. The `FreqAI` framework is effectively a sandbox for the rich world of open-source machine learning libraries. Inside the `FreqAI` sandbox, users find they can combine a wide variety of third-party libraries to test creative hypotheses on a free live 24/7 chaotic data source - cryptocurrency exchange data. 
diff --git a/docs/installation.md b/docs/installation.md
index 11de20e83..a06968dba 100644
--- a/docs/installation.md
+++ b/docs/installation.md
@@ -30,12 +30,6 @@ The easiest way to install and run Freqtrade is to clone the bot Github reposito
 !!! Warning "Up-to-date clock"
     The clock on the system running the bot must be accurate, synchronized to a NTP server frequently enough to avoid problems with communication to the exchanges.
 
-!!! Error "Running setup.py install for gym did not run successfully."
-    If you get an error related with gym we suggest you to downgrade setuptools it to version 65.5.0 you can do it with the following command:
-    ```bash
-    pip install setuptools==65.5.0
-    ```
-
 ------
 
 ## Requirements
@@ -242,6 +236,7 @@ source .env/bin/activate
 
 ```bash
 python3 -m pip install --upgrade pip
+python3 -m pip install -r requirements.txt
 python3 -m pip install -e .
 ```
 
diff --git a/docs/requirements-docs.txt b/docs/requirements-docs.txt
index 91b0e993b..c5e478c78 100644
--- a/docs/requirements-docs.txt
+++ b/docs/requirements-docs.txt
@@ -1,6 +1,6 @@
 markdown==3.3.7
-mkdocs==1.4.2
-mkdocs-material==9.1.7
+mkdocs==1.4.3
+mkdocs-material==9.1.14
 mdx_truly_sane_lists==1.3
-pymdown-extensions==9.11
+pymdown-extensions==10.0.1
 jinja2==3.1.2
diff --git a/docs/rest-api.md b/docs/rest-api.md
index 860a44499..5b33bfa6f 100644
--- a/docs/rest-api.md
+++ b/docs/rest-api.md
@@ -134,7 +134,9 @@ python3 scripts/rest_client.py --config rest_config.json <command> [optional par
 | `reload_config` | Reloads the configuration file.
 | `trades` | List last trades. Limited to 500 trades per call.
 | `trade/<tradeid>` | Get specific trade.
-| `delete_trade <trade_id>` | Remove trade from the database. Tries to close open orders. Requires manual handling of this trade on the exchange.
+| `trade/<tradeid>` | DELETE - Remove trade from the database. Tries to close open orders. Requires manual handling of this trade on the exchange.
+| `trade/<tradeid>/open-order` | DELETE - Cancel open order for this trade.
+| `trade/<tradeid>/reload` | GET - Reload a trade from the Exchange. Only works in live, and can potentially help recover a trade that was manually sold on the exchange.
 | `show_config` | Shows part of the current configuration with relevant settings to operation.
 | `logs` | Shows last log messages.
 | `status` | Lists all open trades.
diff --git a/docs/strategy-advanced.md b/docs/strategy-advanced.md
index a93dcecdf..2749d1281 100644
--- a/docs/strategy-advanced.md
+++ b/docs/strategy-advanced.md
@@ -227,8 +227,8 @@ for val in self.buy_ema_short.range:
         f'ema_short_{val}': ta.EMA(dataframe, timeperiod=val)
     }))
 
-# Append columns to existing dataframe
-merged_frame = pd.concat(frames, axis=1)
+# Combine all dataframes, and reassign the original dataframe column
+dataframe = pd.concat(frames, axis=1)
 ```
 
 Freqtrade does however also counter this by running `dataframe.copy()` on the dataframe right after the `populate_indicators()` method - so performance implications of this should be low to non-existant.
diff --git a/docs/telegram-usage.md b/docs/telegram-usage.md
index fe990790a..1b36c60ad 100644
--- a/docs/telegram-usage.md
+++ b/docs/telegram-usage.md
@@ -187,11 +187,13 @@ official commands. You can ask at any moment for help with `/help`.
 | `/forcelong <pair> [rate]` | Instantly buys the given pair. Rate is optional and only applies to limit orders. (`force_entry_enable` must be set to True)
 | `/forceshort <pair> [rate]` | Instantly shorts the given pair. Rate is optional and only applies to limit orders. This will only work on non-spot markets. (`force_entry_enable` must be set to True)
 | `/delete <trade_id>` | Delete a specific trade from the Database. Tries to close open orders. Requires manual handling of this trade on the exchange.
+| `/reload_trade <trade_id>` | Reload a trade from the Exchange. Only works in live, and can potentially help recover a trade that was manually sold on the exchange.
 | `/cancel_open_order <trade_id> | /coo <trade_id>` | Cancel an open order for a trade.
 | **Metrics** |
 | `/profit [<n>]` | Display a summary of your profit/loss from close trades and some stats about your performance, over the last n days (all trades by default)
 | `/performance` | Show performance of each finished trade grouped by pair
-| `/balance` | Show account balance per currency
+| `/balance` | Show bot managed balance per currency
+| `/balance full` | Show account balance per currency
 | `/daily <n>` | Shows profit or loss per day, over the last n days (n defaults to 7)
 | `/weekly <n>` | Shows profit or loss per week, over the last n weeks (n defaults to 8)
 | `/monthly <n>` | Shows profit or loss per month, over the last n months (n defaults to 6)
@@ -202,7 +204,6 @@ official commands. You can ask at any moment for help with `/help`.
 | `/blacklist [pair]` | Show the current blacklist, or adds a pair to the blacklist.
 | `/edge` | Show validated pairs by Edge if it is enabled.
 
-
 ## Telegram commands in action
 
 Below, example of Telegram message you will receive for each command.
diff --git a/docs/utils.md b/docs/utils.md
index eb675442f..900856af4 100644
--- a/docs/utils.md
+++ b/docs/utils.md
@@ -723,6 +723,9 @@ usage: freqtrade backtesting-analysis [-h] [-v] [--logfile FILE] [-V]
                                       [--exit-reason-list EXIT_REASON_LIST [EXIT_REASON_LIST ...]]
                                       [--indicator-list INDICATOR_LIST [INDICATOR_LIST ...]]
                                       [--timerange YYYYMMDD-[YYYYMMDD]]
+                                      [--rejected]
+                                      [--analysis-to-csv]
+                                      [--analysis-csv-path PATH]
 
 optional arguments:
   -h, --help            show this help message and exit
@@ -736,19 +739,27 @@ optional arguments:
                         pair and enter_tag, 4: by pair, enter_ and exit_tag
                         (this can get quite large)
   --enter-reason-list ENTER_REASON_LIST [ENTER_REASON_LIST ...]
-                        Comma separated list of entry signals to analyse.
-                        Default: all. e.g. 'entry_tag_a,entry_tag_b'
+                        Space separated list of entry signals to analyse.
+                        Default: all. e.g. 'entry_tag_a entry_tag_b'
   --exit-reason-list EXIT_REASON_LIST [EXIT_REASON_LIST ...]
-                        Comma separated list of exit signals to analyse.
+                        Space separated list of exit signals to analyse.
                         Default: all. e.g.
-                        'exit_tag_a,roi,stop_loss,trailing_stop_loss'
+                        'exit_tag_a roi stop_loss trailing_stop_loss'
   --indicator-list INDICATOR_LIST [INDICATOR_LIST ...]
-                        Comma separated list of indicators to analyse. e.g.
-                        'close,rsi,bb_lowerband,profit_abs'
+                        Space separated list of indicators to analyse. e.g.
+                        'close rsi bb_lowerband profit_abs'
   --timerange YYYYMMDD-[YYYYMMDD]
                         Timerange to filter trades for analysis, 
                         start inclusive, end exclusive. e.g.
                         20220101-20220201
+  --rejected
+                        Print out rejected trades table
+  --analysis-to-csv
+                        Write out tables to individual CSVs, by default to 
+                        'user_data/backtest_results' unless '--analysis-csv-path' is given.
+  --analysis-csv-path [PATH]
+                        Optional path where individual CSVs will be written. If not used,
+                        CSVs will be written to 'user_data/backtest_results'.
 
 Common arguments:
   -v, --verbose         Verbose mode (-vv for more, -vvv to get all messages).
diff --git a/freqtrade/__init__.py b/freqtrade/__init__.py
index f190e7204..e7f01f9a5 100644
--- a/freqtrade/__init__.py
+++ b/freqtrade/__init__.py
@@ -1,5 +1,5 @@
 """ Freqtrade bot """
-__version__ = '2023.4'
+__version__ = '2023.5'
 
 if 'dev' in __version__:
     from pathlib import Path
diff --git a/freqtrade/commands/arguments.py b/freqtrade/commands/arguments.py
index 109516f87..8287879c4 100644
--- a/freqtrade/commands/arguments.py
+++ b/freqtrade/commands/arguments.py
@@ -106,7 +106,8 @@ ARGS_HYPEROPT_SHOW = ["hyperopt_list_best", "hyperopt_list_profitable", "hyperop
                       "disableparamexport", "backtest_breakdown"]
 
 ARGS_ANALYZE_ENTRIES_EXITS = ["exportfilename", "analysis_groups", "enter_reason_list",
-                              "exit_reason_list", "indicator_list", "timerange"]
+                              "exit_reason_list", "indicator_list", "timerange",
+                              "analysis_rejected", "analysis_to_csv", "analysis_csv_path"]
 
 NO_CONF_REQURIED = ["convert-data", "convert-trade-data", "download-data", "list-timeframes",
                     "list-markets", "list-pairs", "list-strategies", "list-freqaimodels",
diff --git a/freqtrade/commands/cli_options.py b/freqtrade/commands/cli_options.py
index f1474ec69..f5e6d6926 100644
--- a/freqtrade/commands/cli_options.py
+++ b/freqtrade/commands/cli_options.py
@@ -636,30 +636,45 @@ AVAILABLE_CLI_OPTIONS = {
               "4: by pair, enter_ and exit_tag (this can get quite large), "
               "5: by exit_tag"),
         nargs='+',
-        default=['0', '1', '2'],
+        default=[],
         choices=['0', '1', '2', '3', '4', '5'],
     ),
     "enter_reason_list": Arg(
         "--enter-reason-list",
-        help=("Comma separated list of entry signals to analyse. Default: all. "
-              "e.g. 'entry_tag_a,entry_tag_b'"),
+        help=("Space separated list of entry signals to analyse. Default: all. "
+              "e.g. 'entry_tag_a entry_tag_b'"),
         nargs='+',
         default=['all'],
     ),
     "exit_reason_list": Arg(
         "--exit-reason-list",
-        help=("Comma separated list of exit signals to analyse. Default: all. "
-              "e.g. 'exit_tag_a,roi,stop_loss,trailing_stop_loss'"),
+        help=("Space separated list of exit signals to analyse. Default: all. "
+              "e.g. 'exit_tag_a roi stop_loss trailing_stop_loss'"),
         nargs='+',
         default=['all'],
     ),
     "indicator_list": Arg(
         "--indicator-list",
-        help=("Comma separated list of indicators to analyse. "
-              "e.g. 'close,rsi,bb_lowerband,profit_abs'"),
+        help=("Space separated list of indicators to analyse. "
+              "e.g. 'close rsi bb_lowerband profit_abs'"),
         nargs='+',
         default=[],
     ),
+    "analysis_rejected": Arg(
+        '--rejected-signals',
+        help='Analyse rejected signals',
+        action='store_true',
+    ),
+    "analysis_to_csv": Arg(
+        '--analysis-to-csv',
+        help='Save selected analysis tables to individual CSVs',
+        action='store_true',
+    ),
+    "analysis_csv_path": Arg(
+        '--analysis-csv-path',
+        help=("Specify a path to save the analysis CSVs "
+              "if --analysis-to-csv is enabled. Default: user_data/basktesting_results/"),
+    ),
     "freqaimodel": Arg(
         '--freqaimodel',
         help='Specify a custom freqaimodels.',
diff --git a/freqtrade/commands/data_commands.py b/freqtrade/commands/data_commands.py
index bcef1c252..ed1571002 100644
--- a/freqtrade/commands/data_commands.py
+++ b/freqtrade/commands/data_commands.py
@@ -52,7 +52,7 @@ def start_download_data(args: Dict[str, Any]) -> None:
     pairs_not_available: List[str] = []
 
     # Init exchange
-    exchange = ExchangeResolver.load_exchange(config['exchange']['name'], config, validate=False)
+    exchange = ExchangeResolver.load_exchange(config, validate=False)
     markets = [p for p, m in exchange.markets.items() if market_is_active(m)
                or config.get('include_inactive')]
 
@@ -125,7 +125,7 @@ def start_convert_trades(args: Dict[str, Any]) -> None:
             "Please check the documentation on how to configure this.")
 
     # Init exchange
-    exchange = ExchangeResolver.load_exchange(config['exchange']['name'], config, validate=False)
+    exchange = ExchangeResolver.load_exchange(config, validate=False)
     # Manual validations of relevant settings
     if not config['exchange'].get('skip_pair_validation', False):
         exchange.validate_pairs(config['pairs'])
diff --git a/freqtrade/commands/list_commands.py b/freqtrade/commands/list_commands.py
index 4e0623081..3358f8cc8 100644
--- a/freqtrade/commands/list_commands.py
+++ b/freqtrade/commands/list_commands.py
@@ -114,7 +114,7 @@ def start_list_timeframes(args: Dict[str, Any]) -> None:
     config['timeframe'] = None
 
     # Init exchange
-    exchange = ExchangeResolver.load_exchange(config['exchange']['name'], config, validate=False)
+    exchange = ExchangeResolver.load_exchange(config, validate=False)
 
     if args['print_one_column']:
         print('\n'.join(exchange.timeframes))
@@ -133,7 +133,7 @@ def start_list_markets(args: Dict[str, Any], pairs_only: bool = False) -> None:
     config = setup_utils_configuration(args, RunMode.UTIL_EXCHANGE)
 
     # Init exchange
-    exchange = ExchangeResolver.load_exchange(config['exchange']['name'], config, validate=False)
+    exchange = ExchangeResolver.load_exchange(config, validate=False)
 
     # By default only active pairs/markets are to be shown
     active_only = not args.get('list_pairs_all', False)
diff --git a/freqtrade/commands/pairlist_commands.py b/freqtrade/commands/pairlist_commands.py
index 9f7a5958e..a815cd5f3 100644
--- a/freqtrade/commands/pairlist_commands.py
+++ b/freqtrade/commands/pairlist_commands.py
@@ -18,7 +18,7 @@ def start_test_pairlist(args: Dict[str, Any]) -> None:
     from freqtrade.plugins.pairlistmanager import PairListManager
     config = setup_utils_configuration(args, RunMode.UTIL_EXCHANGE)
 
-    exchange = ExchangeResolver.load_exchange(config['exchange']['name'], config, validate=False)
+    exchange = ExchangeResolver.load_exchange(config, validate=False)
 
     quote_currencies = args.get('quote_currencies')
     if not quote_currencies:
diff --git a/freqtrade/configuration/config_validation.py b/freqtrade/configuration/config_validation.py
index 0ee48cf91..f1745df61 100644
--- a/freqtrade/configuration/config_validation.py
+++ b/freqtrade/configuration/config_validation.py
@@ -174,7 +174,7 @@ def _validate_whitelist(conf: Dict[str, Any]) -> None:
         return
 
     for pl in conf.get('pairlists', [{'method': 'StaticPairList'}]):
-        if (pl.get('method') == 'StaticPairList'
+        if (isinstance(pl, dict) and pl.get('method') == 'StaticPairList'
                 and not conf.get('exchange', {}).get('pair_whitelist')):
             raise OperationalException("StaticPairList requires pair_whitelist to be set.")
 
diff --git a/freqtrade/configuration/configuration.py b/freqtrade/configuration/configuration.py
index 862976eb1..8e9a7fd7c 100644
--- a/freqtrade/configuration/configuration.py
+++ b/freqtrade/configuration/configuration.py
@@ -465,6 +465,15 @@ class Configuration:
         self._args_to_config(config, argname='timerange',
                              logstring='Filter trades by timerange: {}')
 
+        self._args_to_config(config, argname='analysis_rejected',
+                             logstring='Analyse rejected signals: {}')
+
+        self._args_to_config(config, argname='analysis_to_csv',
+                             logstring='Store analysis tables to CSV: {}')
+
+        self._args_to_config(config, argname='analysis_csv_path',
+                             logstring='Path to store analysis CSVs: {}')
+
     def _process_runmode(self, config: Config) -> None:
 
         self._args_to_config(config, argname='dry_run',
diff --git a/freqtrade/configuration/timerange.py b/freqtrade/configuration/timerange.py
index 0c2f0d1b8..cff35db7e 100644
--- a/freqtrade/configuration/timerange.py
+++ b/freqtrade/configuration/timerange.py
@@ -6,8 +6,6 @@ import re
 from datetime import datetime, timezone
 from typing import Optional
 
-import arrow
-
 from freqtrade.constants import DATETIME_PRINT_FORMAT
 from freqtrade.exceptions import OperationalException
 
@@ -139,7 +137,8 @@ class TimeRange:
                 if stype[0]:
                     starts = rvals[index]
                     if stype[0] == 'date' and len(starts) == 8:
-                        start = arrow.get(starts, 'YYYYMMDD').int_timestamp
+                        start = int(datetime.strptime(starts, '%Y%m%d').replace(
+                            tzinfo=timezone.utc).timestamp())
                     elif len(starts) == 13:
                         start = int(starts) // 1000
                     else:
@@ -148,7 +147,8 @@ class TimeRange:
                 if stype[1]:
                     stops = rvals[index]
                     if stype[1] == 'date' and len(stops) == 8:
-                        stop = arrow.get(stops, 'YYYYMMDD').int_timestamp
+                        stop = int(datetime.strptime(stops, '%Y%m%d').replace(
+                            tzinfo=timezone.utc).timestamp())
                     elif len(stops) == 13:
                         stop = int(stops) // 1000
                     else:
diff --git a/freqtrade/constants.py b/freqtrade/constants.py
index b8e240419..3802ec3ad 100644
--- a/freqtrade/constants.py
+++ b/freqtrade/constants.py
@@ -690,4 +690,6 @@ BidAsk = Literal['bid', 'ask']
 OBLiteral = Literal['asks', 'bids']
 
 Config = Dict[str, Any]
+# Exchange part of the configuration.
+ExchangeConfig = Dict[str, Any]
 IntOrInf = float
diff --git a/freqtrade/data/entryexitanalysis.py b/freqtrade/data/entryexitanalysis.py
index 5d67655cd..db3a7d3a4 100644
--- a/freqtrade/data/entryexitanalysis.py
+++ b/freqtrade/data/entryexitanalysis.py
@@ -1,5 +1,6 @@
 import logging
 from pathlib import Path
+from typing import List
 
 import joblib
 import pandas as pd
@@ -15,22 +16,31 @@ from freqtrade.exceptions import OperationalException
 logger = logging.getLogger(__name__)
 
 
-def _load_signal_candles(backtest_dir: Path):
+def _load_backtest_analysis_data(backtest_dir: Path, name: str):
     if backtest_dir.is_dir():
         scpf = Path(backtest_dir,
-                    Path(get_latest_backtest_filename(backtest_dir)).stem + "_signals.pkl"
+                    Path(get_latest_backtest_filename(backtest_dir)).stem + "_" + name + ".pkl"
                     )
     else:
-        scpf = Path(backtest_dir.parent / f"{backtest_dir.stem}_signals.pkl")
+        scpf = Path(backtest_dir.parent / f"{backtest_dir.stem}_{name}.pkl")
 
     try:
         with scpf.open("rb") as scp:
-            signal_candles = joblib.load(scp)
-            logger.info(f"Loaded signal candles: {str(scpf)}")
+            loaded_data = joblib.load(scp)
+            logger.info(f"Loaded {name} candles: {str(scpf)}")
     except Exception as e:
-        logger.error("Cannot load signal candles from pickled results: ", e)
+        logger.error(f"Cannot load {name} data from pickled results: ", e)
+        return None
 
-    return signal_candles
+    return loaded_data
+
+
+def _load_rejected_signals(backtest_dir: Path):
+    return _load_backtest_analysis_data(backtest_dir, "rejected")
+
+
+def _load_signal_candles(backtest_dir: Path):
+    return _load_backtest_analysis_data(backtest_dir, "signals")
 
 
 def _process_candles_and_indicators(pairlist, strategy_name, trades, signal_candles):
@@ -43,9 +53,7 @@ def _process_candles_and_indicators(pairlist, strategy_name, trades, signal_cand
         for pair in pairlist:
             if pair in signal_candles[strategy_name]:
                 analysed_trades_dict[strategy_name][pair] = _analyze_candles_and_indicators(
-                                                              pair,
-                                                              trades,
-                                                              signal_candles[strategy_name][pair])
+                    pair, trades, signal_candles[strategy_name][pair])
     except Exception as e:
         print(f"Cannot process entry/exit reasons for {strategy_name}: ", e)
 
@@ -85,7 +93,7 @@ def _analyze_candles_and_indicators(pair, trades: pd.DataFrame, signal_candles:
         return pd.DataFrame()
 
 
-def _do_group_table_output(bigdf, glist):
+def _do_group_table_output(bigdf, glist, csv_path: Path, to_csv=False, ):
     for g in glist:
         # 0: summary wins/losses grouped by enter tag
         if g == "0":
@@ -116,7 +124,8 @@ def _do_group_table_output(bigdf, glist):
 
             sortcols = ['total_num_buys']
 
-            _print_table(new, sortcols, show_index=True)
+            _print_table(new, sortcols, show_index=True, name="Group 0:",
+                         to_csv=to_csv, csv_path=csv_path)
 
         else:
             agg_mask = {'profit_abs': ['count', 'sum', 'median', 'mean'],
@@ -154,11 +163,24 @@ def _do_group_table_output(bigdf, glist):
                 new['mean_profit_pct'] = new['mean_profit_pct'] * 100
                 new['total_profit_pct'] = new['total_profit_pct'] * 100
 
-                _print_table(new, sortcols)
+                _print_table(new, sortcols, name=f"Group {g}:",
+                             to_csv=to_csv, csv_path=csv_path)
             else:
                 logger.warning("Invalid group mask specified.")
 
 
+def _do_rejected_signals_output(rejected_signals_df: pd.DataFrame,
+                                to_csv: bool = False, csv_path=None) -> None:
+    cols = ['pair', 'date', 'enter_tag']
+    sortcols = ['date', 'pair', 'enter_tag']
+    _print_table(rejected_signals_df[cols],
+                 sortcols,
+                 show_index=False,
+                 name="Rejected Signals:",
+                 to_csv=to_csv,
+                 csv_path=csv_path)
+
+
 def _select_rows_within_dates(df, timerange=None, df_date_col: str = 'date'):
     if timerange:
         if timerange.starttype == 'date':
@@ -192,38 +214,64 @@ def prepare_results(analysed_trades, stratname,
     return res_df
 
 
-def print_results(res_df, analysis_groups, indicator_list):
+def print_results(res_df: pd.DataFrame, analysis_groups: List[str], indicator_list: List[str],
+                  csv_path: Path, rejected_signals=None, to_csv=False):
     if res_df.shape[0] > 0:
         if analysis_groups:
-            _do_group_table_output(res_df, analysis_groups)
+            _do_group_table_output(res_df, analysis_groups, to_csv=to_csv, csv_path=csv_path)
 
+        if rejected_signals is not None:
+            if rejected_signals.empty:
+                print("There were no rejected signals.")
+            else:
+                _do_rejected_signals_output(rejected_signals, to_csv=to_csv, csv_path=csv_path)
+
+        # NB this can be large for big dataframes!
         if "all" in indicator_list:
-            print(res_df)
-        elif indicator_list is not None:
+            _print_table(res_df,
+                         show_index=False,
+                         name="Indicators:",
+                         to_csv=to_csv,
+                         csv_path=csv_path)
+        elif indicator_list is not None and indicator_list:
             available_inds = []
             for ind in indicator_list:
                 if ind in res_df:
                     available_inds.append(ind)
             ilist = ["pair", "enter_reason", "exit_reason"] + available_inds
-            _print_table(res_df[ilist], sortcols=['exit_reason'], show_index=False)
+            _print_table(res_df[ilist],
+                         sortcols=['exit_reason'],
+                         show_index=False,
+                         name="Indicators:",
+                         to_csv=to_csv,
+                         csv_path=csv_path)
     else:
         print("\\No trades to show")
 
 
-def _print_table(df, sortcols=None, show_index=False):
+def _print_table(df: pd.DataFrame, sortcols=None, *, show_index=False, name=None,
+                 to_csv=False, csv_path: Path):
     if (sortcols is not None):
         data = df.sort_values(sortcols)
     else:
         data = df
 
-    print(
-        tabulate(
-            data,
-            headers='keys',
-            tablefmt='psql',
-            showindex=show_index
+    if to_csv:
+        safe_name = Path(csv_path, name.lower().replace(" ", "_").replace(":", "") + ".csv")
+        data.to_csv(safe_name)
+        print(f"Saved {name} to {safe_name}")
+    else:
+        if name is not None:
+            print(name)
+
+        print(
+            tabulate(
+                data,
+                headers='keys',
+                tablefmt='psql',
+                showindex=show_index
+            )
         )
-    )
 
 
 def process_entry_exit_reasons(config: Config):
@@ -232,6 +280,11 @@ def process_entry_exit_reasons(config: Config):
         enter_reason_list = config.get('enter_reason_list', ["all"])
         exit_reason_list = config.get('exit_reason_list', ["all"])
         indicator_list = config.get('indicator_list', [])
+        do_rejected = config.get('analysis_rejected', False)
+        to_csv = config.get('analysis_to_csv', False)
+        csv_path = Path(config.get('analysis_csv_path', config['exportfilename']))
+        if to_csv and not csv_path.is_dir():
+            raise OperationalException(f"Specified directory {csv_path} does not exist.")
 
         timerange = TimeRange.parse_timerange(None if config.get(
             'timerange') is None else str(config.get('timerange')))
@@ -241,8 +294,16 @@ def process_entry_exit_reasons(config: Config):
         for strategy_name, results in backtest_stats['strategy'].items():
             trades = load_backtest_data(config['exportfilename'], strategy_name)
 
-            if not trades.empty:
+            if trades is not None and not trades.empty:
                 signal_candles = _load_signal_candles(config['exportfilename'])
+
+                rej_df = None
+                if do_rejected:
+                    rejected_signals_dict = _load_rejected_signals(config['exportfilename'])
+                    rej_df = prepare_results(rejected_signals_dict, strategy_name,
+                                             enter_reason_list, exit_reason_list,
+                                             timerange=timerange)
+
                 analysed_trades_dict = _process_candles_and_indicators(
                                         config['exchange']['pair_whitelist'], strategy_name,
                                         trades, signal_candles)
@@ -253,7 +314,10 @@ def process_entry_exit_reasons(config: Config):
 
                 print_results(res_df,
                               analysis_groups,
-                              indicator_list)
+                              indicator_list,
+                              rejected_signals=rej_df,
+                              to_csv=to_csv,
+                              csv_path=csv_path)
 
     except ValueError as e:
         raise OperationalException(e) from e
diff --git a/freqtrade/data/history/history_utils.py b/freqtrade/data/history/history_utils.py
index b567b58bf..dc3c7c1e6 100644
--- a/freqtrade/data/history/history_utils.py
+++ b/freqtrade/data/history/history_utils.py
@@ -1,10 +1,9 @@
 import logging
 import operator
-from datetime import datetime
+from datetime import datetime, timedelta
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple
 
-import arrow
 from pandas import DataFrame, concat
 
 from freqtrade.configuration import TimeRange
@@ -236,8 +235,8 @@ def _download_pair_history(pair: str, *,
         new_data = exchange.get_historic_ohlcv(pair=pair,
                                                timeframe=timeframe,
                                                since_ms=since_ms if since_ms else
-                                               arrow.utcnow().shift(
-                                                   days=-new_pairs_days).int_timestamp * 1000,
+                                               int((datetime.now() - timedelta(days=new_pairs_days)
+                                                    ).timestamp()) * 1000,
                                                is_new_pair=data.empty,
                                                candle_type=candle_type,
                                                until_ms=until_ms if until_ms else None
@@ -349,7 +348,7 @@ def _download_trades_history(exchange: Exchange,
             trades = []
 
         if not since:
-            since = arrow.utcnow().shift(days=-new_pairs_days).int_timestamp * 1000
+            since = int((datetime.now() - timedelta(days=-new_pairs_days)).timestamp()) * 1000
 
         from_id = trades[-1][1] if trades else None
         if trades and since < trades[-1][0]:
diff --git a/freqtrade/edge/edge_positioning.py b/freqtrade/edge/edge_positioning.py
index 73820ecbe..f2df0d3f2 100644
--- a/freqtrade/edge/edge_positioning.py
+++ b/freqtrade/edge/edge_positioning.py
@@ -3,9 +3,9 @@
 import logging
 from collections import defaultdict
 from copy import deepcopy
+from datetime import timedelta
 from typing import Any, Dict, List, NamedTuple
 
-import arrow
 import numpy as np
 import utils_find_1st as utf1st
 from pandas import DataFrame
@@ -18,6 +18,7 @@ from freqtrade.exceptions import OperationalException
 from freqtrade.exchange import timeframe_to_seconds
 from freqtrade.plugins.pairlist.pairlist_helpers import expand_pairlist
 from freqtrade.strategy.interface import IStrategy
+from freqtrade.util import dt_now
 
 
 logger = logging.getLogger(__name__)
@@ -79,8 +80,8 @@ class Edge:
             self._stoploss_range_step
         )
 
-        self._timerange: TimeRange = TimeRange.parse_timerange("%s-" % arrow.now().shift(
-            days=-1 * self._since_number_of_days).format('YYYYMMDD'))
+        self._timerange: TimeRange = TimeRange.parse_timerange(
+            f"{(dt_now() - timedelta(days=self._since_number_of_days)).strftime('%Y%m%d')}-")
         if config.get('fee'):
             self.fee = config['fee']
         else:
@@ -97,7 +98,7 @@ class Edge:
         heartbeat = self.edge_config.get('process_throttle_secs')
 
         if (self._last_updated > 0) and (
-                self._last_updated + heartbeat > arrow.utcnow().int_timestamp):
+                self._last_updated + heartbeat > int(dt_now().timestamp())):
             return False
 
         data: Dict[str, Any] = {}
@@ -189,7 +190,7 @@ class Edge:
         # Fill missing, calculable columns, profit, duration , abs etc.
         trades_df = self._fill_calculable_fields(DataFrame(trades))
         self._cached_pairs = self._process_expectancy(trades_df)
-        self._last_updated = arrow.utcnow().int_timestamp
+        self._last_updated = int(dt_now().timestamp())
 
         return True
 
diff --git a/freqtrade/enums/exittype.py b/freqtrade/enums/exittype.py
index b025230ba..c21b62667 100644
--- a/freqtrade/enums/exittype.py
+++ b/freqtrade/enums/exittype.py
@@ -15,6 +15,7 @@ class ExitType(Enum):
     EMERGENCY_EXIT = "emergency_exit"
     CUSTOM_EXIT = "custom_exit"
     PARTIAL_EXIT = "partial_exit"
+    SOLD_ON_EXCHANGE = "sold_on_exchange"
     NONE = ""
 
     def __str__(self):
diff --git a/freqtrade/exchange/__init__.py b/freqtrade/exchange/__init__.py
index 8092d5af8..12fb0c55e 100644
--- a/freqtrade/exchange/__init__.py
+++ b/freqtrade/exchange/__init__.py
@@ -1,6 +1,6 @@
 # flake8: noqa: F401
 # isort: off
-from freqtrade.exchange.common import remove_credentials, MAP_EXCHANGE_CHILDCLASS
+from freqtrade.exchange.common import remove_exchange_credentials, MAP_EXCHANGE_CHILDCLASS
 from freqtrade.exchange.exchange import Exchange
 # isort: on
 from freqtrade.exchange.binance import Binance
diff --git a/freqtrade/exchange/binance.py b/freqtrade/exchange/binance.py
index 7ac496f62..8075d775a 100644
--- a/freqtrade/exchange/binance.py
+++ b/freqtrade/exchange/binance.py
@@ -1,10 +1,9 @@
 """ Binance exchange subclass """
 import logging
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple
 
-import arrow
 import ccxt
 
 from freqtrade.enums import CandleType, MarginMode, PriceType, TradingMode
@@ -66,7 +65,7 @@ class Binance(Exchange):
         """
         try:
             if self.trading_mode == TradingMode.FUTURES and not self._config['dry_run']:
-                position_side = self._api.fapiPrivateGetPositionsideDual()
+                position_side = self._api.fapiPrivateGetPositionSideDual()
                 self._log_exchange_response('position_side_setting', position_side)
                 assets_margin = self._api.fapiPrivateGetMultiAssetsMargin()
                 self._log_exchange_response('multi_asset_margin', assets_margin)
@@ -105,8 +104,9 @@ class Binance(Exchange):
             if x and x[3] and x[3][0] and x[3][0][0] > since_ms:
                 # Set starting date to first available candle.
                 since_ms = x[3][0][0]
-                logger.info(f"Candle-data for {pair} available starting with "
-                            f"{arrow.get(since_ms // 1000).isoformat()}.")
+                logger.info(
+                    f"Candle-data for {pair} available starting with "
+                    f"{datetime.fromtimestamp(since_ms // 1000, tz=timezone.utc).isoformat()}.")
 
         return await super()._async_get_historic_ohlcv(
             pair=pair,
diff --git a/freqtrade/exchange/binance_leverage_tiers.json b/freqtrade/exchange/binance_leverage_tiers.json
index 0b9be0f55..0f252f63e 100644
--- a/freqtrade/exchange/binance_leverage_tiers.json
+++ b/freqtrade/exchange/binance_leverage_tiers.json
@@ -1,4 +1,118 @@
 {
+  "1000FLOKI/USDT:USDT": [
+    {
+      "tier": 1.0,
+      "currency": "USDT",
+      "minNotional": 0.0,
+      "maxNotional": 5000.0,
+      "maintenanceMarginRate": 0.02,
+      "maxLeverage": 20.0,
+      "info": {
+        "bracket": "1",
+        "initialLeverage": "20",
+        "notionalCap": "5000",
+        "notionalFloor": "0",
+        "maintMarginRatio": "0.02",
+        "cum": "0.0"
+      }
+    },
+    {
+      "tier": 2.0,
+      "currency": "USDT",
+      "minNotional": 5000.0,
+      "maxNotional": 25000.0,
+      "maintenanceMarginRate": 0.025,
+      "maxLeverage": 15.0,
+      "info": {
+        "bracket": "2",
+        "initialLeverage": "15",
+        "notionalCap": "25000",
+        "notionalFloor": "5000",
+        "maintMarginRatio": "0.025",
+        "cum": "25.0"
+      }
+    },
+    {
+      "tier": 3.0,
+      "currency": "USDT",
+      "minNotional": 25000.0,
+      "maxNotional": 300000.0,
+      "maintenanceMarginRate": 0.05,
+      "maxLeverage": 10.0,
+      "info": {
+        "bracket": "3",
+        "initialLeverage": "10",
+        "notionalCap": "300000",
+        "notionalFloor": "25000",
+        "maintMarginRatio": "0.05",
+        "cum": "650.0"
+      }
+    },
+    {
+      "tier": 4.0,
+      "currency": "USDT",
+      "minNotional": 300000.0,
+      "maxNotional": 800000.0,
+      "maintenanceMarginRate": 0.1,
+      "maxLeverage": 5.0,
+      "info": {
+        "bracket": "4",
+        "initialLeverage": "5",
+        "notionalCap": "800000",
+        "notionalFloor": "300000",
+        "maintMarginRatio": "0.1",
+        "cum": "15650.0"
+      }
+    },
+    {
+      "tier": 5.0,
+      "currency": "USDT",
+      "minNotional": 800000.0,
+      "maxNotional": 1000000.0,
+      "maintenanceMarginRate": 0.125,
+      "maxLeverage": 4.0,
+      "info": {
+        "bracket": "5",
+        "initialLeverage": "4",
+        "notionalCap": "1000000",
+        "notionalFloor": "800000",
+        "maintMarginRatio": "0.125",
+        "cum": "35650.0"
+      }
+    },
+    {
+      "tier": 6.0,
+      "currency": "USDT",
+      "minNotional": 1000000.0,
+      "maxNotional": 3000000.0,
+      "maintenanceMarginRate": 0.25,
+      "maxLeverage": 2.0,
+      "info": {
+        "bracket": "6",
+        "initialLeverage": "2",
+        "notionalCap": "3000000",
+        "notionalFloor": "1000000",
+        "maintMarginRatio": "0.25",
+        "cum": "160650.0"
+      }
+    },
+    {
+      "tier": 7.0,
+      "currency": "USDT",
+      "minNotional": 3000000.0,
+      "maxNotional": 5000000.0,
+      "maintenanceMarginRate": 0.5,
+      "maxLeverage": 1.0,
+      "info": {
+        "bracket": "7",
+        "initialLeverage": "1",
+        "notionalCap": "5000000",
+        "notionalFloor": "3000000",
+        "maintMarginRatio": "0.5",
+        "cum": "910650.0"
+      }
+    }
+  ],
   "1000LUNC/BUSD:BUSD": [
     {
       "tier": 1.0,
@@ -211,6 +325,120 @@
       }
     }
   ],
+  "1000PEPE/USDT:USDT": [
+    {
+      "tier": 1.0,
+      "currency": "USDT",
+      "minNotional": 0.0,
+      "maxNotional": 5000.0,
+      "maintenanceMarginRate": 0.02,
+      "maxLeverage": 20.0,
+      "info": {
+        "bracket": "1",
+        "initialLeverage": "20",
+        "notionalCap": "5000",
+        "notionalFloor": "0",
+        "maintMarginRatio": "0.02",
+        "cum": "0.0"
+      }
+    },
+    {
+      "tier": 2.0,
+      "currency": "USDT",
+      "minNotional": 5000.0,
+      "maxNotional": 25000.0,
+      "maintenanceMarginRate": 0.025,
+      "maxLeverage": 15.0,
+      "info": {
+        "bracket": "2",
+        "initialLeverage": "15",
+        "notionalCap": "25000",
+        "notionalFloor": "5000",
+        "maintMarginRatio": "0.025",
+        "cum": "25.0"
+      }
+    },
+    {
+      "tier": 3.0,
+      "currency": "USDT",
+      "minNotional": 25000.0,
+      "maxNotional": 600000.0,
+      "maintenanceMarginRate": 0.05,
+      "maxLeverage": 10.0,
+      "info": {
+        "bracket": "3",
+        "initialLeverage": "10",
+        "notionalCap": "600000",
+        "notionalFloor": "25000",
+        "maintMarginRatio": "0.05",
+        "cum": "650.0"
+      }
+    },
+    {
+      "tier": 4.0,
+      "currency": "USDT",
+      "minNotional": 600000.0,
+      "maxNotional": 1600000.0,
+      "maintenanceMarginRate": 0.1,
+      "maxLeverage": 5.0,
+      "info": {
+        "bracket": "4",
+        "initialLeverage": "5",
+        "notionalCap": "1600000",
+        "notionalFloor": "600000",
+        "maintMarginRatio": "0.1",
+        "cum": "30650.0"
+      }
+    },
+    {
+      "tier": 5.0,
+      "currency": "USDT",
+      "minNotional": 1600000.0,
+      "maxNotional": 2000000.0,
+      "maintenanceMarginRate": 0.125,
+      "maxLeverage": 4.0,
+      "info": {
+        "bracket": "5",
+        "initialLeverage": "4",
+        "notionalCap": "2000000",
+        "notionalFloor": "1600000",
+        "maintMarginRatio": "0.125",
+        "cum": "70650.0"
+      }
+    },
+    {
+      "tier": 6.0,
+      "currency": "USDT",
+      "minNotional": 2000000.0,
+      "maxNotional": 6000000.0,
+      "maintenanceMarginRate": 0.25,
+      "maxLeverage": 2.0,
+      "info": {
+        "bracket": "6",
+        "initialLeverage": "2",
+        "notionalCap": "6000000",
+        "notionalFloor": "2000000",
+        "maintMarginRatio": "0.25",
+        "cum": "320650.0"
+      }
+    },
+    {
+      "tier": 7.0,
+      "currency": "USDT",
+      "minNotional": 6000000.0,
+      "maxNotional": 10000000.0,
+      "maintenanceMarginRate": 0.5,
+      "maxLeverage": 1.0,
+      "info": {
+        "bracket": "7",
+        "initialLeverage": "1",
+        "notionalCap": "10000000",
+        "notionalFloor": "6000000",
+        "maintMarginRatio": "0.5",
+        "cum": "1820650.0"
+      }
+    }
+  ],
   "1000SHIB/BUSD:BUSD": [
     {
       "tier": 1.0,
@@ -2174,10 +2402,10 @@
       "minNotional": 0.0,
       "maxNotional": 5000.0,
       "maintenanceMarginRate": 0.02,
-      "maxLeverage": 20.0,
+      "maxLeverage": 10.0,
       "info": {
         "bracket": "1",
-        "initialLeverage": "20",
+        "initialLeverage": "10",
         "notionalCap": "5000",
         "notionalFloor": "0",
         "maintMarginRatio": "0.02",
@@ -2190,10 +2418,10 @@
       "minNotional": 5000.0,
       "maxNotional": 25000.0,
       "maintenanceMarginRate": 0.025,
-      "maxLeverage": 10.0,
+      "maxLeverage": 8.0,
       "info": {
         "bracket": "2",
-        "initialLeverage": "10",
+        "initialLeverage": "8",
         "notionalCap": "25000",
         "notionalFloor": "5000",
         "maintMarginRatio": "0.025",
@@ -2206,10 +2434,10 @@
       "minNotional": 25000.0,
       "maxNotional": 100000.0,
       "maintenanceMarginRate": 0.05,
-      "maxLeverage": 8.0,
+      "maxLeverage": 6.0,
       "info": {
         "bracket": "3",
-        "initialLeverage": "8",
+        "initialLeverage": "6",
         "notionalCap": "100000",
         "notionalFloor": "25000",
         "maintMarginRatio": "0.05",
@@ -2252,13 +2480,13 @@
       "tier": 6.0,
       "currency": "BUSD",
       "minNotional": 1000000.0,
-      "maxNotional": 5000000.0,
+      "maxNotional": 1200000.0,
       "maintenanceMarginRate": 0.5,
       "maxLeverage": 1.0,
       "info": {
         "bracket": "6",
         "initialLeverage": "1",
-        "notionalCap": "5000000",
+        "notionalCap": "1200000",
         "notionalFloor": "1000000",
         "maintMarginRatio": "0.5",
         "cum": "386900.0"
@@ -4821,6 +5049,120 @@
       }
     }
   ],
+  "BLUR/USDT:USDT": [
+    {
+      "tier": 1.0,
+      "currency": "USDT",
+      "minNotional": 0.0,
+      "maxNotional": 5000.0,
+      "maintenanceMarginRate": 0.02,
+      "maxLeverage": 25.0,
+      "info": {
+        "bracket": "1",
+        "initialLeverage": "25",
+        "notionalCap": "5000",
+        "notionalFloor": "0",
+        "maintMarginRatio": "0.02",
+        "cum": "0.0"
+      }
+    },
+    {
+      "tier": 2.0,
+      "currency": "USDT",
+      "minNotional": 5000.0,
+      "maxNotional": 25000.0,
+      "maintenanceMarginRate": 0.025,
+      "maxLeverage": 20.0,
+      "info": {
+        "bracket": "2",
+        "initialLeverage": "20",
+        "notionalCap": "25000",
+        "notionalFloor": "5000",
+        "maintMarginRatio": "0.025",
+        "cum": "25.0"
+      }
+    },
+    {
+      "tier": 3.0,
+      "currency": "USDT",
+      "minNotional": 25000.0,
+      "maxNotional": 600000.0,
+      "maintenanceMarginRate": 0.05,
+      "maxLeverage": 10.0,
+      "info": {
+        "bracket": "3",
+        "initialLeverage": "10",
+        "notionalCap": "600000",
+        "notionalFloor": "25000",
+        "maintMarginRatio": "0.05",
+        "cum": "650.0"
+      }
+    },
+    {
+      "tier": 4.0,
+      "currency": "USDT",
+      "minNotional": 600000.0,
+      "maxNotional": 1600000.0,
+      "maintenanceMarginRate": 0.1,
+      "maxLeverage": 5.0,
+      "info": {
+        "bracket": "4",
+        "initialLeverage": "5",
+        "notionalCap": "1600000",
+        "notionalFloor": "600000",
+        "maintMarginRatio": "0.1",
+        "cum": "30650.0"
+      }
+    },
+    {
+      "tier": 5.0,
+      "currency": "USDT",
+      "minNotional": 1600000.0,
+      "maxNotional": 2000000.0,
+      "maintenanceMarginRate": 0.125,
+      "maxLeverage": 4.0,
+      "info": {
+        "bracket": "5",
+        "initialLeverage": "4",
+        "notionalCap": "2000000",
+        "notionalFloor": "1600000",
+        "maintMarginRatio": "0.125",
+        "cum": "70650.0"
+      }
+    },
+    {
+      "tier": 6.0,
+      "currency": "USDT",
+      "minNotional": 2000000.0,
+      "maxNotional": 6000000.0,
+      "maintenanceMarginRate": 0.25,
+      "maxLeverage": 2.0,
+      "info": {
+        "bracket": "6",
+        "initialLeverage": "2",
+        "notionalCap": "6000000",
+        "notionalFloor": "2000000",
+        "maintMarginRatio": "0.25",
+        "cum": "320650.0"
+      }
+    },
+    {
+      "tier": 7.0,
+      "currency": "USDT",
+      "minNotional": 6000000.0,
+      "maxNotional": 10000000.0,
+      "maintenanceMarginRate": 0.5,
+      "maxLeverage": 1.0,
+      "info": {
+        "bracket": "7",
+        "initialLeverage": "1",
+        "notionalCap": "10000000",
+        "notionalFloor": "6000000",
+        "maintMarginRatio": "0.5",
+        "cum": "1820650.0"
+      }
+    }
+  ],
   "BLZ/USDT:USDT": [
     {
       "tier": 1.0,
@@ -8544,10 +8886,10 @@
       "minNotional": 0.0,
       "maxNotional": 5000.0,
       "maintenanceMarginRate": 0.02,
-      "maxLeverage": 25.0,
+      "maxLeverage": 10.0,
       "info": {
         "bracket": "1",
-        "initialLeverage": "25",
+        "initialLeverage": "10",
         "notionalCap": "5000",
         "notionalFloor": "0",
         "maintMarginRatio": "0.02",
@@ -8560,10 +8902,10 @@
       "minNotional": 5000.0,
       "maxNotional": 25000.0,
       "maintenanceMarginRate": 0.025,
-      "maxLeverage": 15.0,
+      "maxLeverage": 8.0,
       "info": {
         "bracket": "2",
-        "initialLeverage": "15",
+        "initialLeverage": "8",
         "notionalCap": "25000",
         "notionalFloor": "5000",
         "maintMarginRatio": "0.025",
@@ -8576,10 +8918,10 @@
       "minNotional": 25000.0,
       "maxNotional": 100000.0,
       "maintenanceMarginRate": 0.05,
-      "maxLeverage": 10.0,
+      "maxLeverage": 6.0,
       "info": {
         "bracket": "3",
-        "initialLeverage": "10",
+        "initialLeverage": "6",
         "notionalCap": "100000",
         "notionalFloor": "25000",
         "maintMarginRatio": "0.05",
@@ -8638,13 +8980,13 @@
       "tier": 7.0,
       "currency": "BUSD",
       "minNotional": 3000000.0,
-      "maxNotional": 8000000.0,
+      "maxNotional": 4000000.0,
       "maintenanceMarginRate": 0.5,
       "maxLeverage": 1.0,
       "info": {
         "bracket": "7",
         "initialLeverage": "1",
-        "notionalCap": "8000000",
+        "notionalCap": "4000000",
         "notionalFloor": "3000000",
         "maintMarginRatio": "0.5",
         "cum": "949400.0"
@@ -9041,6 +9383,120 @@
       }
     }
   ],
+  "EDU/USDT:USDT": [
+    {
+      "tier": 1.0,
+      "currency": "USDT",
+      "minNotional": 0.0,
+      "maxNotional": 5000.0,
+      "maintenanceMarginRate": 0.02,
+      "maxLeverage": 20.0,
+      "info": {
+        "bracket": "1",
+        "initialLeverage": "20",
+        "notionalCap": "5000",
+        "notionalFloor": "0",
+        "maintMarginRatio": "0.02",
+        "cum": "0.0"
+      }
+    },
+    {
+      "tier": 2.0,
+      "currency": "USDT",
+      "minNotional": 5000.0,
+      "maxNotional": 25000.0,
+      "maintenanceMarginRate": 0.025,
+      "maxLeverage": 15.0,
+      "info": {
+        "bracket": "2",
+        "initialLeverage": "15",
+        "notionalCap": "25000",
+        "notionalFloor": "5000",
+        "maintMarginRatio": "0.025",
+        "cum": "25.0"
+      }
+    },
+    {
+      "tier": 3.0,
+      "currency": "USDT",
+      "minNotional": 25000.0,
+      "maxNotional": 200000.0,
+      "maintenanceMarginRate": 0.05,
+      "maxLeverage": 10.0,
+      "info": {
+        "bracket": "3",
+        "initialLeverage": "10",
+        "notionalCap": "200000",
+        "notionalFloor": "25000",
+        "maintMarginRatio": "0.05",
+        "cum": "650.0"
+      }
+    },
+    {
+      "tier": 4.0,
+      "currency": "USDT",
+      "minNotional": 200000.0,
+      "maxNotional": 500000.0,
+      "maintenanceMarginRate": 0.1,
+      "maxLeverage": 5.0,
+      "info": {
+        "bracket": "4",
+        "initialLeverage": "5",
+        "notionalCap": "500000",
+        "notionalFloor": "200000",
+        "maintMarginRatio": "0.1",
+        "cum": "10650.0"
+      }
+    },
+    {
+      "tier": 5.0,
+      "currency": "USDT",
+      "minNotional": 500000.0,
+      "maxNotional": 1000000.0,
+      "maintenanceMarginRate": 0.125,
+      "maxLeverage": 4.0,
+      "info": {
+        "bracket": "5",
+        "initialLeverage": "4",
+        "notionalCap": "1000000",
+        "notionalFloor": "500000",
+        "maintMarginRatio": "0.125",
+        "cum": "23150.0"
+      }
+    },
+    {
+      "tier": 6.0,
+      "currency": "USDT",
+      "minNotional": 1000000.0,
+      "maxNotional": 3000000.0,
+      "maintenanceMarginRate": 0.25,
+      "maxLeverage": 2.0,
+      "info": {
+        "bracket": "6",
+        "initialLeverage": "2",
+        "notionalCap": "3000000",
+        "notionalFloor": "1000000",
+        "maintMarginRatio": "0.25",
+        "cum": "148150.0"
+      }
+    },
+    {
+      "tier": 7.0,
+      "currency": "USDT",
+      "minNotional": 3000000.0,
+      "maxNotional": 5000000.0,
+      "maintenanceMarginRate": 0.5,
+      "maxLeverage": 1.0,
+      "info": {
+        "bracket": "7",
+        "initialLeverage": "1",
+        "notionalCap": "5000000",
+        "notionalFloor": "3000000",
+        "maintMarginRatio": "0.5",
+        "cum": "898150.0"
+      }
+    }
+  ],
   "EGLD/USDT:USDT": [
     {
       "tier": 1.0,
@@ -9552,10 +10008,10 @@
       "minNotional": 0.0,
       "maxNotional": 5000.0,
       "maintenanceMarginRate": 0.02,
-      "maxLeverage": 20.0,
+      "maxLeverage": 8.0,
       "info": {
         "bracket": "1",
-        "initialLeverage": "20",
+        "initialLeverage": "8",
         "notionalCap": "5000",
         "notionalFloor": "0",
         "maintMarginRatio": "0.02",
@@ -9568,10 +10024,10 @@
       "minNotional": 5000.0,
       "maxNotional": 25000.0,
       "maintenanceMarginRate": 0.025,
-      "maxLeverage": 10.0,
+      "maxLeverage": 7.0,
       "info": {
         "bracket": "2",
-        "initialLeverage": "10",
+        "initialLeverage": "7",
         "notionalCap": "25000",
         "notionalFloor": "5000",
         "maintMarginRatio": "0.025",
@@ -9584,10 +10040,10 @@
       "minNotional": 25000.0,
       "maxNotional": 100000.0,
       "maintenanceMarginRate": 0.05,
-      "maxLeverage": 8.0,
+      "maxLeverage": 6.0,
       "info": {
         "bracket": "3",
-        "initialLeverage": "8",
+        "initialLeverage": "6",
         "notionalCap": "100000",
         "notionalFloor": "25000",
         "maintMarginRatio": "0.05",
@@ -9630,13 +10086,13 @@
       "tier": 6.0,
       "currency": "BUSD",
       "minNotional": 1000000.0,
-      "maxNotional": 5000000.0,
+      "maxNotional": 1500000.0,
       "maintenanceMarginRate": 0.5,
       "maxLeverage": 1.0,
       "info": {
         "bracket": "6",
         "initialLeverage": "1",
-        "notionalCap": "5000000",
+        "notionalCap": "1500000",
         "notionalFloor": "1000000",
         "maintMarginRatio": "0.5",
         "cum": "386900.0"
@@ -9805,6 +10261,168 @@
       }
     }
   ],
+  "ETH/BTC:BTC": [
+    {
+      "tier": 1.0,
+      "currency": "BTC",
+      "minNotional": 0.0,
+      "maxNotional": 5.0,
+      "maintenanceMarginRate": 0.005,
+      "maxLeverage": 75.0,
+      "info": {
+        "bracket": "1",
+        "initialLeverage": "75",
+        "notionalCap": "5",
+        "notionalFloor": "0",
+        "maintMarginRatio": "0.005",
+        "cum": "0.0"
+      }
+    },
+    {
+      "tier": 2.0,
+      "currency": "BTC",
+      "minNotional": 5.0,
+      "maxNotional": 10.0,
+      "maintenanceMarginRate": 0.006,
+      "maxLeverage": 50.0,
+      "info": {
+        "bracket": "2",
+        "initialLeverage": "50",
+        "notionalCap": "10",
+        "notionalFloor": "5",
+        "maintMarginRatio": "0.006",
+        "cum": "0.005"
+      }
+    },
+    {
+      "tier": 3.0,
+      "currency": "BTC",
+      "minNotional": 10.0,
+      "maxNotional": 100.0,
+      "maintenanceMarginRate": 0.01,
+      "maxLeverage": 25.0,
+      "info": {
+        "bracket": "3",
+        "initialLeverage": "25",
+        "notionalCap": "100",
+        "notionalFloor": "10",
+        "maintMarginRatio": "0.01",
+        "cum": "0.045"
+      }
+    },
+    {
+      "tier": 4.0,
+      "currency": "BTC",
+      "minNotional": 100.0,
+      "maxNotional": 250.0,
+      "maintenanceMarginRate": 0.02,
+      "maxLeverage": 20.0,
+      "info": {
+        "bracket": "4",
+        "initialLeverage": "20",
+        "notionalCap": "250",
+        "notionalFloor": "100",
+        "maintMarginRatio": "0.02",
+        "cum": "1.045"
+      }
+    },
+    {
+      "tier": 5.0,
+      "currency": "BTC",
+      "minNotional": 250.0,
+      "maxNotional": 800.0,
+      "maintenanceMarginRate": 0.025,
+      "maxLeverage": 10.0,
+      "info": {
+        "bracket": "5",
+        "initialLeverage": "10",
+        "notionalCap": "800",
+        "notionalFloor": "250",
+        "maintMarginRatio": "0.025",
+        "cum": "2.295"
+      }
+    },
+    {
+      "tier": 6.0,
+      "currency": "BTC",
+      "minNotional": 800.0,
+      "maxNotional": 1500.0,
+      "maintenanceMarginRate": 0.05,
+      "maxLeverage": 8.0,
+      "info": {
+        "bracket": "6",
+        "initialLeverage": "8",
+        "notionalCap": "1500",
+        "notionalFloor": "800",
+        "maintMarginRatio": "0.05",
+        "cum": "22.295"
+      }
+    },
+    {
+      "tier": 7.0,
+      "currency": "BTC",
+      "minNotional": 1500.0,
+      "maxNotional": 2000.0,
+      "maintenanceMarginRate": 0.1,
+      "maxLeverage": 5.0,
+      "info": {
+        "bracket": "7",
+        "initialLeverage": "5",
+        "notionalCap": "2000",
+        "notionalFloor": "1500",
+        "maintMarginRatio": "0.1",
+        "cum": "97.295"
+      }
+    },
+    {
+      "tier": 8.0,
+      "currency": "BTC",
+      "minNotional": 2000.0,
+      "maxNotional": 3000.0,
+      "maintenanceMarginRate": 0.125,
+      "maxLeverage": 4.0,
+      "info": {
+        "bracket": "8",
+        "initialLeverage": "4",
+        "notionalCap": "3000",
+        "notionalFloor": "2000",
+        "maintMarginRatio": "0.125",
+        "cum": "147.295"
+      }
+    },
+    {
+      "tier": 9.0,
+      "currency": "BTC",
+      "minNotional": 3000.0,
+      "maxNotional": 5000.0,
+      "maintenanceMarginRate": 0.25,
+      "maxLeverage": 2.0,
+      "info": {
+        "bracket": "9",
+        "initialLeverage": "2",
+        "notionalCap": "5000",
+        "notionalFloor": "3000",
+        "maintMarginRatio": "0.25",
+        "cum": "522.295"
+      }
+    },
+    {
+      "tier": 10.0,
+      "currency": "BTC",
+      "minNotional": 5000.0,
+      "maxNotional": 10000.0,
+      "maintenanceMarginRate": 0.5,
+      "maxLeverage": 1.0,
+      "info": {
+        "bracket": "10",
+        "initialLeverage": "1",
+        "notionalCap": "10000",
+        "notionalFloor": "5000",
+        "maintMarginRatio": "0.5",
+        "cum": "1772.295"
+      }
+    }
+  ],
   "ETH/BUSD:BUSD": [
     {
       "tier": 1.0,
@@ -10364,10 +10982,10 @@
       "minNotional": 0.0,
       "maxNotional": 5000.0,
       "maintenanceMarginRate": 0.02,
-      "maxLeverage": 20.0,
+      "maxLeverage": 8.0,
       "info": {
         "bracket": "1",
-        "initialLeverage": "20",
+        "initialLeverage": "8",
         "notionalCap": "5000",
         "notionalFloor": "0",
         "maintMarginRatio": "0.02",
@@ -10380,10 +10998,10 @@
       "minNotional": 5000.0,
       "maxNotional": 25000.0,
       "maintenanceMarginRate": 0.025,
-      "maxLeverage": 10.0,
+      "maxLeverage": 7.0,
       "info": {
         "bracket": "2",
-        "initialLeverage": "10",
+        "initialLeverage": "7",
         "notionalCap": "25000",
         "notionalFloor": "5000",
         "maintMarginRatio": "0.025",
@@ -10396,10 +11014,10 @@
       "minNotional": 25000.0,
       "maxNotional": 100000.0,
       "maintenanceMarginRate": 0.05,
-      "maxLeverage": 8.0,
+      "maxLeverage": 6.0,
       "info": {
         "bracket": "3",
-        "initialLeverage": "8",
+        "initialLeverage": "6",
         "notionalCap": "100000",
         "notionalFloor": "25000",
         "maintMarginRatio": "0.05",
@@ -10442,13 +11060,13 @@
       "tier": 6.0,
       "currency": "BUSD",
       "minNotional": 1000000.0,
-      "maxNotional": 5000000.0,
+      "maxNotional": 2000000.0,
       "maintenanceMarginRate": 0.5,
       "maxLeverage": 1.0,
       "info": {
         "bracket": "6",
         "initialLeverage": "1",
-        "notionalCap": "5000000",
+        "notionalCap": "2000000",
         "notionalFloor": "1000000",
         "maintMarginRatio": "0.5",
         "cum": "386900.0"
@@ -13341,6 +13959,120 @@
       }
     }
   ],
+  "IDEX/USDT:USDT": [
+    {
+      "tier": 1.0,
+      "currency": "USDT",
+      "minNotional": 0.0,
+      "maxNotional": 5000.0,
+      "maintenanceMarginRate": 0.02,
+      "maxLeverage": 20.0,
+      "info": {
+        "bracket": "1",
+        "initialLeverage": "20",
+        "notionalCap": "5000",
+        "notionalFloor": "0",
+        "maintMarginRatio": "0.02",
+        "cum": "0.0"
+      }
+    },
+    {
+      "tier": 2.0,
+      "currency": "USDT",
+      "minNotional": 5000.0,
+      "maxNotional": 25000.0,
+      "maintenanceMarginRate": 0.025,
+      "maxLeverage": 15.0,
+      "info": {
+        "bracket": "2",
+        "initialLeverage": "15",
+        "notionalCap": "25000",
+        "notionalFloor": "5000",
+        "maintMarginRatio": "0.025",
+        "cum": "25.0"
+      }
+    },
+    {
+      "tier": 3.0,
+      "currency": "USDT",
+      "minNotional": 25000.0,
+      "maxNotional": 200000.0,
+      "maintenanceMarginRate": 0.05,
+      "maxLeverage": 10.0,
+      "info": {
+        "bracket": "3",
+        "initialLeverage": "10",
+        "notionalCap": "200000",
+        "notionalFloor": "25000",
+        "maintMarginRatio": "0.05",
+        "cum": "650.0"
+      }
+    },
+    {
+      "tier": 4.0,
+      "currency": "USDT",
+      "minNotional": 200000.0,
+      "maxNotional": 500000.0,
+      "maintenanceMarginRate": 0.1,
+      "maxLeverage": 5.0,
+      "info": {
+        "bracket": "4",
+        "initialLeverage": "5",
+        "notionalCap": "500000",
+        "notionalFloor": "200000",
+        "maintMarginRatio": "0.1",
+        "cum": "10650.0"
+      }
+    },
+    {
+      "tier": 5.0,
+      "currency": "USDT",
+      "minNotional": 500000.0,
+      "maxNotional": 1000000.0,
+      "maintenanceMarginRate": 0.125,
+      "maxLeverage": 4.0,
+      "info": {
+        "bracket": "5",
+        "initialLeverage": "4",
+        "notionalCap": "1000000",
+        "notionalFloor": "500000",
+        "maintMarginRatio": "0.125",
+        "cum": "23150.0"
+      }
+    },
+    {
+      "tier": 6.0,
+      "currency": "USDT",
+      "minNotional": 1000000.0,
+      "maxNotional": 3000000.0,
+      "maintenanceMarginRate": 0.25,
+      "maxLeverage": 2.0,
+      "info": {
+        "bracket": "6",
+        "initialLeverage": "2",
+        "notionalCap": "3000000",
+        "notionalFloor": "1000000",
+        "maintMarginRatio": "0.25",
+        "cum": "148150.0"
+      }
+    },
+    {
+      "tier": 7.0,
+      "currency": "USDT",
+      "minNotional": 3000000.0,
+      "maxNotional": 5000000.0,
+      "maintenanceMarginRate": 0.5,
+      "maxLeverage": 1.0,
+      "info": {
+        "bracket": "7",
+        "initialLeverage": "1",
+        "notionalCap": "5000000",
+        "notionalFloor": "3000000",
+        "maintMarginRatio": "0.5",
+        "cum": "898150.0"
+      }
+    }
+  ],
   "IMX/USDT:USDT": [
     {
       "tier": 1.0,
@@ -13492,13 +14224,13 @@
       "tier": 3.0,
       "currency": "USDT",
       "minNotional": 25000.0,
-      "maxNotional": 600000.0,
+      "maxNotional": 1200000.0,
       "maintenanceMarginRate": 0.05,
       "maxLeverage": 10.0,
       "info": {
         "bracket": "3",
         "initialLeverage": "10",
-        "notionalCap": "600000",
+        "notionalCap": "1200000",
         "notionalFloor": "25000",
         "maintMarginRatio": "0.05",
         "cum": "650.0"
@@ -13507,65 +14239,65 @@
     {
       "tier": 4.0,
       "currency": "USDT",
-      "minNotional": 600000.0,
-      "maxNotional": 1600000.0,
+      "minNotional": 1200000.0,
+      "maxNotional": 3200000.0,
       "maintenanceMarginRate": 0.1,
       "maxLeverage": 5.0,
       "info": {
         "bracket": "4",
         "initialLeverage": "5",
-        "notionalCap": "1600000",
-        "notionalFloor": "600000",
+        "notionalCap": "3200000",
+        "notionalFloor": "1200000",
         "maintMarginRatio": "0.1",
-        "cum": "30650.0"
+        "cum": "60650.0"
       }
     },
     {
       "tier": 5.0,
       "currency": "USDT",
-      "minNotional": 1600000.0,
-      "maxNotional": 2000000.0,
+      "minNotional": 3200000.0,
+      "maxNotional": 4000000.0,
       "maintenanceMarginRate": 0.125,
       "maxLeverage": 4.0,
       "info": {
         "bracket": "5",
         "initialLeverage": "4",
-        "notionalCap": "2000000",
-        "notionalFloor": "1600000",
+        "notionalCap": "4000000",
+        "notionalFloor": "3200000",
         "maintMarginRatio": "0.125",
-        "cum": "70650.0"
+        "cum": "140650.0"
       }
     },
     {
       "tier": 6.0,
       "currency": "USDT",
-      "minNotional": 2000000.0,
-      "maxNotional": 6000000.0,
+      "minNotional": 4000000.0,
+      "maxNotional": 12000000.0,
       "maintenanceMarginRate": 0.25,
       "maxLeverage": 2.0,
       "info": {
         "bracket": "6",
         "initialLeverage": "2",
-        "notionalCap": "6000000",
-        "notionalFloor": "2000000",
+        "notionalCap": "12000000",
+        "notionalFloor": "4000000",
         "maintMarginRatio": "0.25",
-        "cum": "320650.0"
+        "cum": "640650.0"
       }
     },
     {
       "tier": 7.0,
       "currency": "USDT",
-      "minNotional": 6000000.0,
-      "maxNotional": 10000000.0,
+      "minNotional": 12000000.0,
+      "maxNotional": 20000000.0,
       "maintenanceMarginRate": 0.5,
       "maxLeverage": 1.0,
       "info": {
         "bracket": "7",
         "initialLeverage": "1",
-        "notionalCap": "10000000",
-        "notionalFloor": "6000000",
+        "notionalCap": "20000000",
+        "notionalFloor": "12000000",
         "maintMarginRatio": "0.5",
-        "cum": "1820650.0"
+        "cum": "3640650.0"
       }
     }
   ],
@@ -15562,13 +16294,13 @@
       "tier": 3.0,
       "currency": "USDT",
       "minNotional": 25000.0,
-      "maxNotional": 200000.0,
+      "maxNotional": 600000.0,
       "maintenanceMarginRate": 0.05,
       "maxLeverage": 10.0,
       "info": {
         "bracket": "3",
         "initialLeverage": "10",
-        "notionalCap": "200000",
+        "notionalCap": "600000",
         "notionalFloor": "25000",
         "maintMarginRatio": "0.05",
         "cum": "650.0"
@@ -15577,65 +16309,65 @@
     {
       "tier": 4.0,
       "currency": "USDT",
-      "minNotional": 200000.0,
-      "maxNotional": 500000.0,
+      "minNotional": 600000.0,
+      "maxNotional": 1600000.0,
       "maintenanceMarginRate": 0.1,
       "maxLeverage": 5.0,
       "info": {
         "bracket": "4",
         "initialLeverage": "5",
-        "notionalCap": "500000",
-        "notionalFloor": "200000",
+        "notionalCap": "1600000",
+        "notionalFloor": "600000",
         "maintMarginRatio": "0.1",
-        "cum": "10650.0"
+        "cum": "30650.0"
       }
     },
     {
       "tier": 5.0,
       "currency": "USDT",
-      "minNotional": 500000.0,
-      "maxNotional": 1000000.0,
+      "minNotional": 1600000.0,
+      "maxNotional": 2000000.0,
       "maintenanceMarginRate": 0.125,
       "maxLeverage": 4.0,
       "info": {
         "bracket": "5",
         "initialLeverage": "4",
-        "notionalCap": "1000000",
-        "notionalFloor": "500000",
+        "notionalCap": "2000000",
+        "notionalFloor": "1600000",
         "maintMarginRatio": "0.125",
-        "cum": "23150.0"
+        "cum": "70650.0"
       }
     },
     {
       "tier": 6.0,
       "currency": "USDT",
-      "minNotional": 1000000.0,
-      "maxNotional": 3000000.0,
+      "minNotional": 2000000.0,
+      "maxNotional": 6000000.0,
       "maintenanceMarginRate": 0.25,
       "maxLeverage": 2.0,
       "info": {
         "bracket": "6",
         "initialLeverage": "2",
-        "notionalCap": "3000000",
-        "notionalFloor": "1000000",
+        "notionalCap": "6000000",
+        "notionalFloor": "2000000",
         "maintMarginRatio": "0.25",
-        "cum": "148150.0"
+        "cum": "320650.0"
       }
     },
     {
       "tier": 7.0,
       "currency": "USDT",
-      "minNotional": 3000000.0,
-      "maxNotional": 5000000.0,
+      "minNotional": 6000000.0,
+      "maxNotional": 10000000.0,
       "maintenanceMarginRate": 0.5,
       "maxLeverage": 1.0,
       "info": {
         "bracket": "7",
         "initialLeverage": "1",
-        "notionalCap": "5000000",
-        "notionalFloor": "3000000",
+        "notionalCap": "10000000",
+        "notionalFloor": "6000000",
         "maintMarginRatio": "0.5",
-        "cum": "898150.0"
+        "cum": "1820650.0"
       }
     }
   ],
@@ -17746,10 +18478,10 @@
       "minNotional": 0.0,
       "maxNotional": 5000.0,
       "maintenanceMarginRate": 0.02,
-      "maxLeverage": 20.0,
+      "maxLeverage": 25.0,
       "info": {
         "bracket": "1",
-        "initialLeverage": "20",
+        "initialLeverage": "25",
         "notionalCap": "5000",
         "notionalFloor": "0",
         "maintMarginRatio": "0.02",
@@ -17762,10 +18494,10 @@
       "minNotional": 5000.0,
       "maxNotional": 25000.0,
       "maintenanceMarginRate": 0.025,
-      "maxLeverage": 10.0,
+      "maxLeverage": 20.0,
       "info": {
         "bracket": "2",
-        "initialLeverage": "10",
+        "initialLeverage": "20",
         "notionalCap": "25000",
         "notionalFloor": "5000",
         "maintMarginRatio": "0.025",
@@ -17778,10 +18510,10 @@
       "minNotional": 25000.0,
       "maxNotional": 900000.0,
       "maintenanceMarginRate": 0.05,
-      "maxLeverage": 8.0,
+      "maxLeverage": 10.0,
       "info": {
         "bracket": "3",
-        "initialLeverage": "8",
+        "initialLeverage": "10",
         "notionalCap": "900000",
         "notionalFloor": "25000",
         "maintMarginRatio": "0.05",
@@ -18202,10 +18934,10 @@
       "minNotional": 0.0,
       "maxNotional": 5000.0,
       "maintenanceMarginRate": 0.02,
-      "maxLeverage": 20.0,
+      "maxLeverage": 25.0,
       "info": {
         "bracket": "1",
-        "initialLeverage": "20",
+        "initialLeverage": "25",
         "notionalCap": "5000",
         "notionalFloor": "0",
         "maintMarginRatio": "0.02",
@@ -18218,10 +18950,10 @@
       "minNotional": 5000.0,
       "maxNotional": 25000.0,
       "maintenanceMarginRate": 0.025,
-      "maxLeverage": 10.0,
+      "maxLeverage": 20.0,
       "info": {
         "bracket": "2",
-        "initialLeverage": "10",
+        "initialLeverage": "20",
         "notionalCap": "25000",
         "notionalFloor": "5000",
         "maintMarginRatio": "0.025",
@@ -18232,13 +18964,13 @@
       "tier": 3.0,
       "currency": "USDT",
       "minNotional": 25000.0,
-      "maxNotional": 100000.0,
+      "maxNotional": 300000.0,
       "maintenanceMarginRate": 0.05,
-      "maxLeverage": 8.0,
+      "maxLeverage": 10.0,
       "info": {
         "bracket": "3",
-        "initialLeverage": "8",
-        "notionalCap": "100000",
+        "initialLeverage": "10",
+        "notionalCap": "300000",
         "notionalFloor": "25000",
         "maintMarginRatio": "0.05",
         "cum": "650.0"
@@ -18247,33 +18979,33 @@
     {
       "tier": 4.0,
       "currency": "USDT",
-      "minNotional": 100000.0,
-      "maxNotional": 250000.0,
+      "minNotional": 300000.0,
+      "maxNotional": 800000.0,
       "maintenanceMarginRate": 0.1,
       "maxLeverage": 5.0,
       "info": {
         "bracket": "4",
         "initialLeverage": "5",
-        "notionalCap": "250000",
-        "notionalFloor": "100000",
+        "notionalCap": "800000",
+        "notionalFloor": "300000",
         "maintMarginRatio": "0.1",
-        "cum": "5650.0"
+        "cum": "15650.0"
       }
     },
     {
       "tier": 5.0,
       "currency": "USDT",
-      "minNotional": 250000.0,
+      "minNotional": 800000.0,
       "maxNotional": 1000000.0,
       "maintenanceMarginRate": 0.125,
-      "maxLeverage": 2.0,
+      "maxLeverage": 4.0,
       "info": {
         "bracket": "5",
-        "initialLeverage": "2",
+        "initialLeverage": "4",
         "notionalCap": "1000000",
-        "notionalFloor": "250000",
+        "notionalFloor": "800000",
         "maintMarginRatio": "0.125",
-        "cum": "11900.0"
+        "cum": "35650.0"
       }
     },
     {
@@ -18281,15 +19013,31 @@
       "currency": "USDT",
       "minNotional": 1000000.0,
       "maxNotional": 3000000.0,
+      "maintenanceMarginRate": 0.25,
+      "maxLeverage": 2.0,
+      "info": {
+        "bracket": "6",
+        "initialLeverage": "2",
+        "notionalCap": "3000000",
+        "notionalFloor": "1000000",
+        "maintMarginRatio": "0.25",
+        "cum": "160650.0"
+      }
+    },
+    {
+      "tier": 7.0,
+      "currency": "USDT",
+      "minNotional": 3000000.0,
+      "maxNotional": 5000000.0,
       "maintenanceMarginRate": 0.5,
       "maxLeverage": 1.0,
       "info": {
-        "bracket": "6",
+        "bracket": "7",
         "initialLeverage": "1",
-        "notionalCap": "3000000",
-        "notionalFloor": "1000000",
+        "notionalCap": "5000000",
+        "notionalFloor": "3000000",
         "maintMarginRatio": "0.5",
-        "cum": "386900.0"
+        "cum": "910650.0"
       }
     }
   ],
@@ -18815,6 +19563,120 @@
       }
     }
   ],
+  "RAD/USDT:USDT": [
+    {
+      "tier": 1.0,
+      "currency": "USDT",
+      "minNotional": 0.0,
+      "maxNotional": 5000.0,
+      "maintenanceMarginRate": 0.02,
+      "maxLeverage": 20.0,
+      "info": {
+        "bracket": "1",
+        "initialLeverage": "20",
+        "notionalCap": "5000",
+        "notionalFloor": "0",
+        "maintMarginRatio": "0.02",
+        "cum": "0.0"
+      }
+    },
+    {
+      "tier": 2.0,
+      "currency": "USDT",
+      "minNotional": 5000.0,
+      "maxNotional": 25000.0,
+      "maintenanceMarginRate": 0.025,
+      "maxLeverage": 15.0,
+      "info": {
+        "bracket": "2",
+        "initialLeverage": "15",
+        "notionalCap": "25000",
+        "notionalFloor": "5000",
+        "maintMarginRatio": "0.025",
+        "cum": "25.0"
+      }
+    },
+    {
+      "tier": 3.0,
+      "currency": "USDT",
+      "minNotional": 25000.0,
+      "maxNotional": 200000.0,
+      "maintenanceMarginRate": 0.05,
+      "maxLeverage": 10.0,
+      "info": {
+        "bracket": "3",
+        "initialLeverage": "10",
+        "notionalCap": "200000",
+        "notionalFloor": "25000",
+        "maintMarginRatio": "0.05",
+        "cum": "650.0"
+      }
+    },
+    {
+      "tier": 4.0,
+      "currency": "USDT",
+      "minNotional": 200000.0,
+      "maxNotional": 500000.0,
+      "maintenanceMarginRate": 0.1,
+      "maxLeverage": 5.0,
+      "info": {
+        "bracket": "4",
+        "initialLeverage": "5",
+        "notionalCap": "500000",
+        "notionalFloor": "200000",
+        "maintMarginRatio": "0.1",
+        "cum": "10650.0"
+      }
+    },
+    {
+      "tier": 5.0,
+      "currency": "USDT",
+      "minNotional": 500000.0,
+      "maxNotional": 1000000.0,
+      "maintenanceMarginRate": 0.125,
+      "maxLeverage": 4.0,
+      "info": {
+        "bracket": "5",
+        "initialLeverage": "4",
+        "notionalCap": "1000000",
+        "notionalFloor": "500000",
+        "maintMarginRatio": "0.125",
+        "cum": "23150.0"
+      }
+    },
+    {
+      "tier": 6.0,
+      "currency": "USDT",
+      "minNotional": 1000000.0,
+      "maxNotional": 3000000.0,
+      "maintenanceMarginRate": 0.25,
+      "maxLeverage": 2.0,
+      "info": {
+        "bracket": "6",
+        "initialLeverage": "2",
+        "notionalCap": "3000000",
+        "notionalFloor": "1000000",
+        "maintMarginRatio": "0.25",
+        "cum": "148150.0"
+      }
+    },
+    {
+      "tier": 7.0,
+      "currency": "USDT",
+      "minNotional": 3000000.0,
+      "maxNotional": 5000000.0,
+      "maintenanceMarginRate": 0.5,
+      "maxLeverage": 1.0,
+      "info": {
+        "bracket": "7",
+        "initialLeverage": "1",
+        "notionalCap": "5000000",
+        "notionalFloor": "3000000",
+        "maintMarginRatio": "0.5",
+        "cum": "898150.0"
+      }
+    }
+  ],
   "RAY/USDT:USDT": [
     {
       "tier": 1.0,
@@ -18950,13 +19812,13 @@
       "tier": 3.0,
       "currency": "USDT",
       "minNotional": 25000.0,
-      "maxNotional": 200000.0,
+      "maxNotional": 600000.0,
       "maintenanceMarginRate": 0.05,
       "maxLeverage": 10.0,
       "info": {
         "bracket": "3",
         "initialLeverage": "10",
-        "notionalCap": "200000",
+        "notionalCap": "600000",
         "notionalFloor": "25000",
         "maintMarginRatio": "0.05",
         "cum": "650.0"
@@ -18965,65 +19827,65 @@
     {
       "tier": 4.0,
       "currency": "USDT",
-      "minNotional": 200000.0,
-      "maxNotional": 500000.0,
+      "minNotional": 600000.0,
+      "maxNotional": 1600000.0,
       "maintenanceMarginRate": 0.1,
       "maxLeverage": 5.0,
       "info": {
         "bracket": "4",
         "initialLeverage": "5",
-        "notionalCap": "500000",
-        "notionalFloor": "200000",
+        "notionalCap": "1600000",
+        "notionalFloor": "600000",
         "maintMarginRatio": "0.1",
-        "cum": "10650.0"
+        "cum": "30650.0"
       }
     },
     {
       "tier": 5.0,
       "currency": "USDT",
-      "minNotional": 500000.0,
-      "maxNotional": 1000000.0,
+      "minNotional": 1600000.0,
+      "maxNotional": 2000000.0,
       "maintenanceMarginRate": 0.125,
       "maxLeverage": 4.0,
       "info": {
         "bracket": "5",
         "initialLeverage": "4",
-        "notionalCap": "1000000",
-        "notionalFloor": "500000",
+        "notionalCap": "2000000",
+        "notionalFloor": "1600000",
         "maintMarginRatio": "0.125",
-        "cum": "23150.0"
+        "cum": "70650.0"
       }
     },
     {
       "tier": 6.0,
       "currency": "USDT",
-      "minNotional": 1000000.0,
-      "maxNotional": 3000000.0,
+      "minNotional": 2000000.0,
+      "maxNotional": 6000000.0,
       "maintenanceMarginRate": 0.25,
       "maxLeverage": 2.0,
       "info": {
         "bracket": "6",
         "initialLeverage": "2",
-        "notionalCap": "3000000",
-        "notionalFloor": "1000000",
+        "notionalCap": "6000000",
+        "notionalFloor": "2000000",
         "maintMarginRatio": "0.25",
-        "cum": "148150.0"
+        "cum": "320650.0"
       }
     },
     {
       "tier": 7.0,
       "currency": "USDT",
-      "minNotional": 3000000.0,
-      "maxNotional": 5000000.0,
+      "minNotional": 6000000.0,
+      "maxNotional": 10000000.0,
       "maintenanceMarginRate": 0.5,
       "maxLeverage": 1.0,
       "info": {
         "bracket": "7",
         "initialLeverage": "1",
-        "notionalCap": "5000000",
-        "notionalFloor": "3000000",
+        "notionalCap": "10000000",
+        "notionalFloor": "6000000",
         "maintMarginRatio": "0.5",
-        "cum": "898150.0"
+        "cum": "1820650.0"
       }
     }
   ],
@@ -21412,13 +22274,13 @@
       "tier": 2.0,
       "currency": "USDT",
       "minNotional": 5000.0,
-      "maxNotional": 25000.0,
+      "maxNotional": 50000.0,
       "maintenanceMarginRate": 0.025,
       "maxLeverage": 20.0,
       "info": {
         "bracket": "2",
         "initialLeverage": "20",
-        "notionalCap": "25000",
+        "notionalCap": "50000",
         "notionalFloor": "5000",
         "maintMarginRatio": "0.025",
         "cum": "75.0"
@@ -21427,39 +22289,39 @@
     {
       "tier": 3.0,
       "currency": "USDT",
-      "minNotional": 25000.0,
-      "maxNotional": 400000.0,
+      "minNotional": 50000.0,
+      "maxNotional": 600000.0,
       "maintenanceMarginRate": 0.05,
       "maxLeverage": 10.0,
       "info": {
         "bracket": "3",
         "initialLeverage": "10",
-        "notionalCap": "400000",
-        "notionalFloor": "25000",
+        "notionalCap": "600000",
+        "notionalFloor": "50000",
         "maintMarginRatio": "0.05",
-        "cum": "700.0"
+        "cum": "1325.0"
       }
     },
     {
       "tier": 4.0,
       "currency": "USDT",
-      "minNotional": 400000.0,
-      "maxNotional": 1000000.0,
+      "minNotional": 600000.0,
+      "maxNotional": 1600000.0,
       "maintenanceMarginRate": 0.1,
       "maxLeverage": 5.0,
       "info": {
         "bracket": "4",
         "initialLeverage": "5",
-        "notionalCap": "1000000",
-        "notionalFloor": "400000",
+        "notionalCap": "1600000",
+        "notionalFloor": "600000",
         "maintMarginRatio": "0.1",
-        "cum": "20700.0"
+        "cum": "31325.0"
       }
     },
     {
       "tier": 5.0,
       "currency": "USDT",
-      "minNotional": 1000000.0,
+      "minNotional": 1600000.0,
       "maxNotional": 2000000.0,
       "maintenanceMarginRate": 0.125,
       "maxLeverage": 4.0,
@@ -21467,9 +22329,9 @@
         "bracket": "5",
         "initialLeverage": "4",
         "notionalCap": "2000000",
-        "notionalFloor": "1000000",
+        "notionalFloor": "1600000",
         "maintMarginRatio": "0.125",
-        "cum": "45700.0"
+        "cum": "71325.0"
       }
     },
     {
@@ -21485,7 +22347,7 @@
         "notionalCap": "6000000",
         "notionalFloor": "2000000",
         "maintMarginRatio": "0.25",
-        "cum": "295700.0"
+        "cum": "321325.0"
       }
     },
     {
@@ -21501,7 +22363,137 @@
         "notionalCap": "10000000",
         "notionalFloor": "6000000",
         "maintMarginRatio": "0.5",
-        "cum": "1795700.0"
+        "cum": "1821325.0"
+      }
+    }
+  ],
+  "SUI/USDT:USDT": [
+    {
+      "tier": 1.0,
+      "currency": "USDT",
+      "minNotional": 0.0,
+      "maxNotional": 5000.0,
+      "maintenanceMarginRate": 0.01,
+      "maxLeverage": 50.0,
+      "info": {
+        "bracket": "1",
+        "initialLeverage": "50",
+        "notionalCap": "5000",
+        "notionalFloor": "0",
+        "maintMarginRatio": "0.01",
+        "cum": "0.0"
+      }
+    },
+    {
+      "tier": 2.0,
+      "currency": "USDT",
+      "minNotional": 5000.0,
+      "maxNotional": 50000.0,
+      "maintenanceMarginRate": 0.02,
+      "maxLeverage": 25.0,
+      "info": {
+        "bracket": "2",
+        "initialLeverage": "25",
+        "notionalCap": "50000",
+        "notionalFloor": "5000",
+        "maintMarginRatio": "0.02",
+        "cum": "50.0"
+      }
+    },
+    {
+      "tier": 3.0,
+      "currency": "USDT",
+      "minNotional": 50000.0,
+      "maxNotional": 300000.0,
+      "maintenanceMarginRate": 0.025,
+      "maxLeverage": 20.0,
+      "info": {
+        "bracket": "3",
+        "initialLeverage": "20",
+        "notionalCap": "300000",
+        "notionalFloor": "50000",
+        "maintMarginRatio": "0.025",
+        "cum": "300.0"
+      }
+    },
+    {
+      "tier": 4.0,
+      "currency": "USDT",
+      "minNotional": 300000.0,
+      "maxNotional": 600000.0,
+      "maintenanceMarginRate": 0.05,
+      "maxLeverage": 10.0,
+      "info": {
+        "bracket": "4",
+        "initialLeverage": "10",
+        "notionalCap": "600000",
+        "notionalFloor": "300000",
+        "maintMarginRatio": "0.05",
+        "cum": "7800.0"
+      }
+    },
+    {
+      "tier": 5.0,
+      "currency": "USDT",
+      "minNotional": 600000.0,
+      "maxNotional": 1600000.0,
+      "maintenanceMarginRate": 0.1,
+      "maxLeverage": 5.0,
+      "info": {
+        "bracket": "5",
+        "initialLeverage": "5",
+        "notionalCap": "1600000",
+        "notionalFloor": "600000",
+        "maintMarginRatio": "0.1",
+        "cum": "37800.0"
+      }
+    },
+    {
+      "tier": 6.0,
+      "currency": "USDT",
+      "minNotional": 1600000.0,
+      "maxNotional": 2000000.0,
+      "maintenanceMarginRate": 0.125,
+      "maxLeverage": 4.0,
+      "info": {
+        "bracket": "6",
+        "initialLeverage": "4",
+        "notionalCap": "2000000",
+        "notionalFloor": "1600000",
+        "maintMarginRatio": "0.125",
+        "cum": "77800.0"
+      }
+    },
+    {
+      "tier": 7.0,
+      "currency": "USDT",
+      "minNotional": 2000000.0,
+      "maxNotional": 6000000.0,
+      "maintenanceMarginRate": 0.25,
+      "maxLeverage": 2.0,
+      "info": {
+        "bracket": "7",
+        "initialLeverage": "2",
+        "notionalCap": "6000000",
+        "notionalFloor": "2000000",
+        "maintMarginRatio": "0.25",
+        "cum": "327800.0"
+      }
+    },
+    {
+      "tier": 8.0,
+      "currency": "USDT",
+      "minNotional": 6000000.0,
+      "maxNotional": 10000000.0,
+      "maintenanceMarginRate": 0.5,
+      "maxLeverage": 1.0,
+      "info": {
+        "bracket": "8",
+        "initialLeverage": "1",
+        "notionalCap": "10000000",
+        "notionalFloor": "6000000",
+        "maintMarginRatio": "0.5",
+        "cum": "1827800.0"
       }
     }
   ],
@@ -22759,6 +23751,120 @@
       }
     }
   ],
+  "UMA/USDT:USDT": [
+    {
+      "tier": 1.0,
+      "currency": "USDT",
+      "minNotional": 0.0,
+      "maxNotional": 5000.0,
+      "maintenanceMarginRate": 0.02,
+      "maxLeverage": 20.0,
+      "info": {
+        "bracket": "1",
+        "initialLeverage": "20",
+        "notionalCap": "5000",
+        "notionalFloor": "0",
+        "maintMarginRatio": "0.02",
+        "cum": "0.0"
+      }
+    },
+    {
+      "tier": 2.0,
+      "currency": "USDT",
+      "minNotional": 5000.0,
+      "maxNotional": 25000.0,
+      "maintenanceMarginRate": 0.025,
+      "maxLeverage": 15.0,
+      "info": {
+        "bracket": "2",
+        "initialLeverage": "15",
+        "notionalCap": "25000",
+        "notionalFloor": "5000",
+        "maintMarginRatio": "0.025",
+        "cum": "25.0"
+      }
+    },
+    {
+      "tier": 3.0,
+      "currency": "USDT",
+      "minNotional": 25000.0,
+      "maxNotional": 200000.0,
+      "maintenanceMarginRate": 0.05,
+      "maxLeverage": 10.0,
+      "info": {
+        "bracket": "3",
+        "initialLeverage": "10",
+        "notionalCap": "200000",
+        "notionalFloor": "25000",
+        "maintMarginRatio": "0.05",
+        "cum": "650.0"
+      }
+    },
+    {
+      "tier": 4.0,
+      "currency": "USDT",
+      "minNotional": 200000.0,
+      "maxNotional": 500000.0,
+      "maintenanceMarginRate": 0.1,
+      "maxLeverage": 5.0,
+      "info": {
+        "bracket": "4",
+        "initialLeverage": "5",
+        "notionalCap": "500000",
+        "notionalFloor": "200000",
+        "maintMarginRatio": "0.1",
+        "cum": "10650.0"
+      }
+    },
+    {
+      "tier": 5.0,
+      "currency": "USDT",
+      "minNotional": 500000.0,
+      "maxNotional": 1000000.0,
+      "maintenanceMarginRate": 0.125,
+      "maxLeverage": 4.0,
+      "info": {
+        "bracket": "5",
+        "initialLeverage": "4",
+        "notionalCap": "1000000",
+        "notionalFloor": "500000",
+        "maintMarginRatio": "0.125",
+        "cum": "23150.0"
+      }
+    },
+    {
+      "tier": 6.0,
+      "currency": "USDT",
+      "minNotional": 1000000.0,
+      "maxNotional": 3000000.0,
+      "maintenanceMarginRate": 0.25,
+      "maxLeverage": 2.0,
+      "info": {
+        "bracket": "6",
+        "initialLeverage": "2",
+        "notionalCap": "3000000",
+        "notionalFloor": "1000000",
+        "maintMarginRatio": "0.25",
+        "cum": "148150.0"
+      }
+    },
+    {
+      "tier": 7.0,
+      "currency": "USDT",
+      "minNotional": 3000000.0,
+      "maxNotional": 5000000.0,
+      "maintenanceMarginRate": 0.5,
+      "maxLeverage": 1.0,
+      "info": {
+        "bracket": "7",
+        "initialLeverage": "1",
+        "notionalCap": "5000000",
+        "notionalFloor": "3000000",
+        "maintMarginRatio": "0.5",
+        "cum": "898150.0"
+      }
+    }
+  ],
   "UNFI/USDT:USDT": [
     {
       "tier": 1.0,
@@ -24818,10 +25924,10 @@
       "minNotional": 0.0,
       "maxNotional": 5000.0,
       "maintenanceMarginRate": 0.01,
-      "maxLeverage": 20.0,
+      "maxLeverage": 25.0,
       "info": {
         "bracket": "1",
-        "initialLeverage": "20",
+        "initialLeverage": "25",
         "notionalCap": "5000",
         "notionalFloor": "0",
         "maintMarginRatio": "0.01",
@@ -24834,10 +25940,10 @@
       "minNotional": 5000.0,
       "maxNotional": 25000.0,
       "maintenanceMarginRate": 0.025,
-      "maxLeverage": 10.0,
+      "maxLeverage": 20.0,
       "info": {
         "bracket": "2",
-        "initialLeverage": "10",
+        "initialLeverage": "20",
         "notionalCap": "25000",
         "notionalFloor": "5000",
         "maintMarginRatio": "0.025",
@@ -24848,13 +25954,13 @@
       "tier": 3.0,
       "currency": "USDT",
       "minNotional": 25000.0,
-      "maxNotional": 100000.0,
+      "maxNotional": 600000.0,
       "maintenanceMarginRate": 0.05,
-      "maxLeverage": 8.0,
+      "maxLeverage": 10.0,
       "info": {
         "bracket": "3",
-        "initialLeverage": "8",
-        "notionalCap": "100000",
+        "initialLeverage": "10",
+        "notionalCap": "600000",
         "notionalFloor": "25000",
         "maintMarginRatio": "0.05",
         "cum": "700.0"
@@ -24863,49 +25969,65 @@
     {
       "tier": 4.0,
       "currency": "USDT",
-      "minNotional": 100000.0,
-      "maxNotional": 250000.0,
+      "minNotional": 600000.0,
+      "maxNotional": 1600000.0,
       "maintenanceMarginRate": 0.1,
       "maxLeverage": 5.0,
       "info": {
         "bracket": "4",
         "initialLeverage": "5",
-        "notionalCap": "250000",
-        "notionalFloor": "100000",
+        "notionalCap": "1600000",
+        "notionalFloor": "600000",
         "maintMarginRatio": "0.1",
-        "cum": "5700.0"
+        "cum": "30700.0"
       }
     },
     {
       "tier": 5.0,
       "currency": "USDT",
-      "minNotional": 250000.0,
-      "maxNotional": 1000000.0,
+      "minNotional": 1600000.0,
+      "maxNotional": 2000000.0,
       "maintenanceMarginRate": 0.125,
-      "maxLeverage": 2.0,
+      "maxLeverage": 4.0,
       "info": {
         "bracket": "5",
-        "initialLeverage": "2",
-        "notionalCap": "1000000",
-        "notionalFloor": "250000",
+        "initialLeverage": "4",
+        "notionalCap": "2000000",
+        "notionalFloor": "1600000",
         "maintMarginRatio": "0.125",
-        "cum": "11950.0"
+        "cum": "70700.0"
       }
     },
     {
       "tier": 6.0,
       "currency": "USDT",
-      "minNotional": 1000000.0,
-      "maxNotional": 5000000.0,
+      "minNotional": 2000000.0,
+      "maxNotional": 6000000.0,
+      "maintenanceMarginRate": 0.25,
+      "maxLeverage": 2.0,
+      "info": {
+        "bracket": "6",
+        "initialLeverage": "2",
+        "notionalCap": "6000000",
+        "notionalFloor": "2000000",
+        "maintMarginRatio": "0.25",
+        "cum": "320700.0"
+      }
+    },
+    {
+      "tier": 7.0,
+      "currency": "USDT",
+      "minNotional": 6000000.0,
+      "maxNotional": 10000000.0,
       "maintenanceMarginRate": 0.5,
       "maxLeverage": 1.0,
       "info": {
-        "bracket": "6",
+        "bracket": "7",
         "initialLeverage": "1",
-        "notionalCap": "5000000",
-        "notionalFloor": "1000000",
+        "notionalCap": "10000000",
+        "notionalFloor": "6000000",
         "maintMarginRatio": "0.5",
-        "cum": "386950.0"
+        "cum": "1820700.0"
       }
     }
   ],
diff --git a/freqtrade/exchange/common.py b/freqtrade/exchange/common.py
index 42a7094ba..10dfdf178 100644
--- a/freqtrade/exchange/common.py
+++ b/freqtrade/exchange/common.py
@@ -4,6 +4,7 @@ import time
 from functools import wraps
 from typing import Any, Callable, Optional, TypeVar, cast, overload
 
+from freqtrade.constants import ExchangeConfig
 from freqtrade.exceptions import DDosProtection, RetryableOrderError, TemporaryError
 from freqtrade.mixins import LoggingMixin
 
@@ -84,20 +85,22 @@ EXCHANGE_HAS_OPTIONAL = [
     # 'fetchPositions',  # Futures trading
     # 'fetchLeverageTiers',  # Futures initialization
     # 'fetchMarketLeverageTiers',  # Futures initialization
+    # 'fetchOpenOrders', 'fetchClosedOrders',  # 'fetchOrders',  # Refinding balance...
 ]
 
 
-def remove_credentials(config) -> None:
+def remove_exchange_credentials(exchange_config: ExchangeConfig, dry_run: bool) -> None:
     """
     Removes exchange keys from the configuration and specifies dry-run
     Used for backtesting / hyperopt / edge and utils.
     Modifies the input dict!
     """
-    if config.get('dry_run', False):
-        config['exchange']['key'] = ''
-        config['exchange']['secret'] = ''
-        config['exchange']['password'] = ''
-        config['exchange']['uid'] = ''
+    if dry_run:
+        exchange_config['key'] = ''
+        exchange_config['apiKey'] = ''
+        exchange_config['secret'] = ''
+        exchange_config['password'] = ''
+        exchange_config['uid'] = ''
 
 
 def calculate_backoff(retrycount, max_retries):
diff --git a/freqtrade/exchange/exchange.py b/freqtrade/exchange/exchange.py
index 7e276d538..3b1466c69 100644
--- a/freqtrade/exchange/exchange.py
+++ b/freqtrade/exchange/exchange.py
@@ -11,7 +11,6 @@ from math import floor
 from threading import Lock
 from typing import Any, Coroutine, Dict, List, Literal, Optional, Tuple, Union
 
-import arrow
 import ccxt
 import ccxt.async_support as ccxt_async
 from cachetools import TTLCache
@@ -20,16 +19,16 @@ from dateutil import parser
 from pandas import DataFrame, concat
 
 from freqtrade.constants import (DEFAULT_AMOUNT_RESERVE_PERCENT, NON_OPEN_EXCHANGE_STATES, BidAsk,
-                                 BuySell, Config, EntryExit, ListPairsWithTimeframes, MakerTaker,
-                                 OBLiteral, PairWithTimeframe)
+                                 BuySell, Config, EntryExit, ExchangeConfig,
+                                 ListPairsWithTimeframes, MakerTaker, OBLiteral, PairWithTimeframe)
 from freqtrade.data.converter import clean_ohlcv_dataframe, ohlcv_to_dataframe, trades_dict_to_list
 from freqtrade.enums import OPTIMIZE_MODES, CandleType, MarginMode, TradingMode
 from freqtrade.enums.pricetype import PriceType
 from freqtrade.exceptions import (DDosProtection, ExchangeError, InsufficientFundsError,
                                   InvalidOrderException, OperationalException, PricingError,
                                   RetryableOrderError, TemporaryError)
-from freqtrade.exchange.common import (API_FETCH_ORDER_RETRY_COUNT, remove_credentials, retrier,
-                                       retrier_async)
+from freqtrade.exchange.common import (API_FETCH_ORDER_RETRY_COUNT, remove_exchange_credentials,
+                                       retrier, retrier_async)
 from freqtrade.exchange.exchange_utils import (ROUND, ROUND_DOWN, ROUND_UP, CcxtModuleType,
                                                amount_to_contract_precision, amount_to_contracts,
                                                amount_to_precision, contracts_to_amount,
@@ -42,6 +41,8 @@ from freqtrade.exchange.types import OHLCVResponse, OrderBook, Ticker, Tickers
 from freqtrade.misc import (chunks, deep_merge_dicts, file_dump_json, file_load_json,
                             safe_value_fallback2)
 from freqtrade.plugins.pairlist.pairlist_helpers import expand_pairlist
+from freqtrade.util import dt_from_ts, dt_now
+from freqtrade.util.datetime_helpers import dt_humanize, dt_ts
 
 
 logger = logging.getLogger(__name__)
@@ -92,8 +93,8 @@ class Exchange:
         # TradingMode.SPOT always supported and not required in this list
     ]
 
-    def __init__(self, config: Config, validate: bool = True,
-                 load_leverage_tiers: bool = False) -> None:
+    def __init__(self, config: Config, *, exchange_config: Optional[ExchangeConfig] = None,
+                 validate: bool = True, load_leverage_tiers: bool = False) -> None:
         """
         Initializes this module with the given config,
         it does basic validation whether the specified exchange and pairs are valid.
@@ -107,8 +108,7 @@ class Exchange:
         # Lock event loop. This is necessary to avoid race-conditions when using force* commands
         # Due to funding fee fetching.
         self._loop_lock = Lock()
-        self.loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(self.loop)
+        self.loop = self._init_async_loop()
         self._config: Config = {}
 
         self._config.update(config)
@@ -132,13 +132,13 @@ class Exchange:
 
         # Holds all open sell orders for dry_run
         self._dry_run_open_orders: Dict[str, Any] = {}
-        remove_credentials(config)
 
         if config['dry_run']:
             logger.info('Instance is running with dry_run enabled')
         logger.info(f"Using CCXT {ccxt.__version__}")
-        exchange_config = config['exchange']
-        self.log_responses = exchange_config.get('log_responses', False)
+        exchange_conf: Dict[str, Any] = exchange_config if exchange_config else config['exchange']
+        remove_exchange_credentials(exchange_conf, config.get('dry_run', False))
+        self.log_responses = exchange_conf.get('log_responses', False)
 
         # Leverage properties
         self.trading_mode: TradingMode = config.get('trading_mode', TradingMode.SPOT)
@@ -153,8 +153,8 @@ class Exchange:
         self._ft_has = deep_merge_dicts(self._ft_has, deepcopy(self._ft_has_default))
         if self.trading_mode == TradingMode.FUTURES:
             self._ft_has = deep_merge_dicts(self._ft_has_futures, self._ft_has)
-        if exchange_config.get('_ft_has_params'):
-            self._ft_has = deep_merge_dicts(exchange_config.get('_ft_has_params'),
+        if exchange_conf.get('_ft_has_params'):
+            self._ft_has = deep_merge_dicts(exchange_conf.get('_ft_has_params'),
                                             self._ft_has)
             logger.info("Overriding exchange._ft_has with config params, result: %s", self._ft_has)
 
@@ -166,18 +166,18 @@ class Exchange:
 
         # Initialize ccxt objects
         ccxt_config = self._ccxt_config
-        ccxt_config = deep_merge_dicts(exchange_config.get('ccxt_config', {}), ccxt_config)
-        ccxt_config = deep_merge_dicts(exchange_config.get('ccxt_sync_config', {}), ccxt_config)
+        ccxt_config = deep_merge_dicts(exchange_conf.get('ccxt_config', {}), ccxt_config)
+        ccxt_config = deep_merge_dicts(exchange_conf.get('ccxt_sync_config', {}), ccxt_config)
 
-        self._api = self._init_ccxt(exchange_config, ccxt_kwargs=ccxt_config)
+        self._api = self._init_ccxt(exchange_conf, ccxt_kwargs=ccxt_config)
 
         ccxt_async_config = self._ccxt_config
-        ccxt_async_config = deep_merge_dicts(exchange_config.get('ccxt_config', {}),
+        ccxt_async_config = deep_merge_dicts(exchange_conf.get('ccxt_config', {}),
                                              ccxt_async_config)
-        ccxt_async_config = deep_merge_dicts(exchange_config.get('ccxt_async_config', {}),
+        ccxt_async_config = deep_merge_dicts(exchange_conf.get('ccxt_async_config', {}),
                                              ccxt_async_config)
         self._api_async = self._init_ccxt(
-            exchange_config, ccxt_async, ccxt_kwargs=ccxt_async_config)
+            exchange_conf, ccxt_async, ccxt_kwargs=ccxt_async_config)
 
         logger.info(f'Using Exchange "{self.name}"')
         self.required_candle_call_count = 1
@@ -190,7 +190,7 @@ class Exchange:
                 self._startup_candle_count, config.get('timeframe', ''))
 
         # Converts the interval provided in minutes in config to seconds
-        self.markets_refresh_interval: int = exchange_config.get(
+        self.markets_refresh_interval: int = exchange_conf.get(
             "markets_refresh_interval", 60) * 60
 
         if self.trading_mode != TradingMode.SPOT and load_leverage_tiers:
@@ -212,6 +212,11 @@ class Exchange:
         if self.loop and not self.loop.is_closed():
             self.loop.close()
 
+    def _init_async_loop(self) -> asyncio.AbstractEventLoop:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        return loop
+
     def validate_config(self, config):
         # Check if timeframe is available
         self.validate_timeframes(config.get('timeframe'))
@@ -486,7 +491,7 @@ class Exchange:
         try:
             self._markets = self._api.load_markets(params={})
             self._load_async_markets()
-            self._last_markets_refresh = arrow.utcnow().int_timestamp
+            self._last_markets_refresh = dt_ts()
             if self._ft_has['needs_trading_fees']:
                 self._trading_fees = self.fetch_trading_fees()
 
@@ -497,15 +502,14 @@ class Exchange:
         """Reload markets both sync and async if refresh interval has passed """
         # Check whether markets have to be reloaded
         if (self._last_markets_refresh > 0) and (
-                self._last_markets_refresh + self.markets_refresh_interval
-                > arrow.utcnow().int_timestamp):
+                self._last_markets_refresh + self.markets_refresh_interval > dt_ts()):
             return None
         logger.debug("Performing scheduled market reload..")
         try:
             self._markets = self._api.load_markets(reload=True, params={})
             # Also reload async markets to avoid issues with newly listed pairs
             self._load_async_markets(reload=True)
-            self._last_markets_refresh = arrow.utcnow().int_timestamp
+            self._last_markets_refresh = dt_ts()
             self.fill_leverage_tiers()
         except ccxt.BaseError:
             logger.exception("Could not reload markets.")
@@ -839,7 +843,8 @@ class Exchange:
     def create_dry_run_order(self, pair: str, ordertype: str, side: str, amount: float,
                              rate: float, leverage: float, params: Dict = {},
                              stop_loss: bool = False) -> Dict[str, Any]:
-        order_id = f'dry_run_{side}_{datetime.now().timestamp()}'
+        now = dt_now()
+        order_id = f'dry_run_{side}_{now.timestamp()}'
         # Rounding here must respect to contract sizes
         _amount = self._contracts_to_amount(
             pair, self.amount_to_precision(pair, self._amount_to_contracts(pair, amount)))
@@ -854,8 +859,8 @@ class Exchange:
             'side': side,
             'filled': 0,
             'remaining': _amount,
-            'datetime': arrow.utcnow().strftime('%Y-%m-%dT%H:%M:%S.%fZ'),
-            'timestamp': arrow.utcnow().int_timestamp * 1000,
+            'datetime': now.strftime('%Y-%m-%dT%H:%M:%S.%fZ'),
+            'timestamp': dt_ts(now),
             'status': "open",
             'fee': None,
             'info': {},
@@ -863,7 +868,7 @@ class Exchange:
         }
         if stop_loss:
             dry_order["info"] = {"stopPrice": dry_order["price"]}
-            dry_order["stopPrice"] = dry_order["price"]
+            dry_order[self._ft_has['stop_price_param']] = dry_order["price"]
             # Workaround to avoid filling stoploss orders immediately
             dry_order["ft_order_type"] = "stoploss"
         orderbook: Optional[OrderBook] = None
@@ -1015,7 +1020,7 @@ class Exchange:
             from freqtrade.persistence import Order
             order = Order.order_by_id(order_id)
             if order:
-                ccxt_order = order.to_ccxt_object()
+                ccxt_order = order.to_ccxt_object(self._ft_has['stop_price_param'])
                 self._dry_run_open_orders[order_id] = ccxt_order
                 return ccxt_order
             # Gracefully handle errors with dry-run orders.
@@ -1428,6 +1433,47 @@ class Exchange:
         except ccxt.BaseError as e:
             raise OperationalException(e) from e
 
+    @retrier(retries=0)
+    def fetch_orders(self, pair: str, since: datetime) -> List[Dict]:
+        """
+        Fetch all orders for a pair "since"
+        :param pair: Pair for the query
+        :param since: Starting time for the query
+        """
+        if self._config['dry_run']:
+            return []
+
+        def fetch_orders_emulate() -> List[Dict]:
+            orders = []
+            if self.exchange_has('fetchClosedOrders'):
+                orders = self._api.fetch_closed_orders(pair, since=since_ms)
+                if self.exchange_has('fetchOpenOrders'):
+                    orders_open = self._api.fetch_open_orders(pair, since=since_ms)
+                    orders.extend(orders_open)
+            return orders
+
+        try:
+            since_ms = int((since.timestamp() - 10) * 1000)
+            if self.exchange_has('fetchOrders'):
+                try:
+                    orders: List[Dict] = self._api.fetch_orders(pair, since=since_ms)
+                except ccxt.NotSupported:
+                    # Some exchanges don't support fetchOrders
+                    # attempt to fetch open and closed orders separately
+                    orders = fetch_orders_emulate()
+            else:
+                orders = fetch_orders_emulate()
+            self._log_exchange_response('fetch_orders', orders)
+            orders = [self._order_contracts_to_amount(o) for o in orders]
+            return orders
+        except ccxt.DDoSProtection as e:
+            raise DDosProtection(e) from e
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not fetch positions due to {e.__class__.__name__}. Message: {e}') from e
+        except ccxt.BaseError as e:
+            raise OperationalException(e) from e
+
     @retrier
     def fetch_trading_fees(self) -> Dict[str, Any]:
         """
@@ -1885,11 +1931,11 @@ class Exchange:
         logger.debug(
             "one_call: %s msecs (%s)",
             one_call,
-            arrow.utcnow().shift(seconds=one_call // 1000).humanize(only_distance=True)
+            dt_humanize(dt_now() - timedelta(milliseconds=one_call), only_distance=True)
         )
         input_coroutines = [self._async_get_candle_history(
             pair, timeframe, candle_type, since) for since in
-            range(since_ms, until_ms or (arrow.utcnow().int_timestamp * 1000), one_call)]
+            range(since_ms, until_ms or dt_ts(), one_call)]
 
         data: List = []
         # Chunk requests into batches of 100 to avoid overwelming ccxt Throttling
@@ -2072,7 +2118,7 @@ class Exchange:
         """
         try:
             # Fetch OHLCV asynchronously
-            s = '(' + arrow.get(since_ms // 1000).isoformat() + ') ' if since_ms is not None else ''
+            s = '(' + dt_from_ts(since_ms).isoformat() + ') ' if since_ms is not None else ''
             logger.debug(
                 "Fetching pair %s, %s, interval %s, since %s %s...",
                 pair, candle_type, timeframe, since_ms, s
@@ -2162,7 +2208,7 @@ class Exchange:
                 logger.debug(
                     "Fetching trades for pair %s, since %s %s...",
                     pair, since,
-                    '(' + arrow.get(since // 1000).isoformat() + ') ' if since is not None else ''
+                    '(' + dt_from_ts(since).isoformat() + ') ' if since is not None else ''
                 )
                 trades = await self._api_async.fetch_trades(pair, since=since, limit=1000)
             trades = self._trades_contracts_to_amount(trades)
@@ -2896,8 +2942,8 @@ class Exchange:
                 if nominal_value >= tier['minNotional']:
                     return (tier['maintenanceMarginRate'], tier['maintAmt'])
 
-            raise OperationalException("nominal value can not be lower than 0")
+            raise ExchangeError("nominal value can not be lower than 0")
             # The lowest notional_floor for any pair in fetch_leverage_tiers is always 0 because it
             # describes the min amt for a tier, and the lowest tier will always go down to 0
         else:
-            raise OperationalException(f"Cannot get maintenance ratio using {self.name}")
+            raise ExchangeError(f"Cannot get maintenance ratio using {self.name}")
diff --git a/freqtrade/exchange/exchange_utils.py b/freqtrade/exchange/exchange_utils.py
index 83d2a214d..c6c2d5a24 100644
--- a/freqtrade/exchange/exchange_utils.py
+++ b/freqtrade/exchange/exchange_utils.py
@@ -11,6 +11,7 @@ from ccxt import (DECIMAL_PLACES, ROUND, ROUND_DOWN, ROUND_UP, SIGNIFICANT_DIGIT
 
 from freqtrade.exchange.common import BAD_EXCHANGES, EXCHANGE_HAS_OPTIONAL, EXCHANGE_HAS_REQUIRED
 from freqtrade.util import FtPrecise
+from freqtrade.util.datetime_helpers import dt_from_ts, dt_ts
 
 
 CcxtModuleType = Any
@@ -99,9 +100,8 @@ def timeframe_to_prev_date(timeframe: str, date: Optional[datetime] = None) -> d
     if not date:
         date = datetime.now(timezone.utc)
 
-    new_timestamp = ccxt.Exchange.round_timeframe(timeframe, date.timestamp() * 1000,
-                                                  ROUND_DOWN) // 1000
-    return datetime.fromtimestamp(new_timestamp, tz=timezone.utc)
+    new_timestamp = ccxt.Exchange.round_timeframe(timeframe, dt_ts(date), ROUND_DOWN) // 1000
+    return dt_from_ts(new_timestamp)
 
 
 def timeframe_to_next_date(timeframe: str, date: Optional[datetime] = None) -> datetime:
@@ -113,9 +113,8 @@ def timeframe_to_next_date(timeframe: str, date: Optional[datetime] = None) -> d
     """
     if not date:
         date = datetime.now(timezone.utc)
-    new_timestamp = ccxt.Exchange.round_timeframe(timeframe, date.timestamp() * 1000,
-                                                  ROUND_UP) // 1000
-    return datetime.fromtimestamp(new_timestamp, tz=timezone.utc)
+    new_timestamp = ccxt.Exchange.round_timeframe(timeframe, dt_ts(date), ROUND_UP) // 1000
+    return dt_from_ts(new_timestamp)
 
 
 def date_minus_candles(
diff --git a/freqtrade/exchange/okx.py b/freqtrade/exchange/okx.py
index 84b7deb7a..af889897c 100644
--- a/freqtrade/exchange/okx.py
+++ b/freqtrade/exchange/okx.py
@@ -169,6 +169,22 @@ class Okx(Exchange):
             params['posSide'] = self._get_posSide(side, True)
         return params
 
+    def _convert_stop_order(self, pair: str, order_id: str, order: Dict) -> Dict:
+        if (
+            order['status'] == 'closed'
+            and (real_order_id := order.get('info', {}).get('ordId')) is not None
+        ):
+            # Once a order triggered, we fetch the regular followup order.
+            order_reg = self.fetch_order(real_order_id, pair)
+            self._log_exchange_response('fetch_stoploss_order1', order_reg)
+            order_reg['id_stop'] = order_reg['id']
+            order_reg['id'] = order_id
+            order_reg['type'] = 'stoploss'
+            order_reg['status_stop'] = 'triggered'
+            return order_reg
+        order['type'] = 'stoploss'
+        return order
+
     def fetch_stoploss_order(self, order_id: str, pair: str, params: Dict = {}) -> Dict:
         if self._config['dry_run']:
             return self.fetch_dry_run_order(order_id)
@@ -177,7 +193,7 @@ class Okx(Exchange):
             params1 = {'stop': True}
             order_reg = self._api.fetch_order(order_id, pair, params=params1)
             self._log_exchange_response('fetch_stoploss_order', order_reg)
-            return order_reg
+            return self._convert_stop_order(pair, order_id, order_reg)
         except ccxt.OrderNotFound:
             pass
         params2 = {'stop': True, 'ordType': 'conditional'}
@@ -188,18 +204,7 @@ class Okx(Exchange):
                 orders_f = [order for order in orders if order['id'] == order_id]
                 if orders_f:
                     order = orders_f[0]
-                    if (order['status'] == 'closed'
-                            and (real_order_id := order.get('info', {}).get('ordId')) is not None):
-                        # Once a order triggered, we fetch the regular followup order.
-                        order_reg = self.fetch_order(real_order_id, pair)
-                        self._log_exchange_response('fetch_stoploss_order1', order_reg)
-                        order_reg['id_stop'] = order_reg['id']
-                        order_reg['id'] = order_id
-                        order_reg['type'] = 'stoploss'
-                        order_reg['status_stop'] = 'triggered'
-                        return order_reg
-                    order['type'] = 'stoploss'
-                    return order
+                    return self._convert_stop_order(pair, order_id, order)
             except ccxt.BaseError:
                 pass
         raise RetryableOrderError(
diff --git a/freqtrade/freqai/RL/Base3ActionRLEnv.py b/freqtrade/freqai/RL/Base3ActionRLEnv.py
index c0a7eedaa..538ca3a6a 100644
--- a/freqtrade/freqai/RL/Base3ActionRLEnv.py
+++ b/freqtrade/freqai/RL/Base3ActionRLEnv.py
@@ -1,7 +1,7 @@
 import logging
 from enum import Enum
 
-from gym import spaces
+from gymnasium import spaces
 
 from freqtrade.freqai.RL.BaseEnvironment import BaseEnvironment, Positions
 
@@ -94,9 +94,12 @@ class Base3ActionRLEnv(BaseEnvironment):
 
         observation = self._get_observation()
 
+        # user can play with time if they want
+        truncated = False
+
         self._update_history(info)
 
-        return observation, step_reward, self._done, info
+        return observation, step_reward, self._done, truncated, info
 
     def is_tradesignal(self, action: int) -> bool:
         """
diff --git a/freqtrade/freqai/RL/Base4ActionRLEnv.py b/freqtrade/freqai/RL/Base4ActionRLEnv.py
index e883136b2..12f10d4fc 100644
--- a/freqtrade/freqai/RL/Base4ActionRLEnv.py
+++ b/freqtrade/freqai/RL/Base4ActionRLEnv.py
@@ -1,7 +1,7 @@
 import logging
 from enum import Enum
 
-from gym import spaces
+from gymnasium import spaces
 
 from freqtrade.freqai.RL.BaseEnvironment import BaseEnvironment, Positions
 
@@ -96,9 +96,12 @@ class Base4ActionRLEnv(BaseEnvironment):
 
         observation = self._get_observation()
 
+        # user can play with time if they want
+        truncated = False
+
         self._update_history(info)
 
-        return observation, step_reward, self._done, info
+        return observation, step_reward, self._done, truncated, info
 
     def is_tradesignal(self, action: int) -> bool:
         """
diff --git a/freqtrade/freqai/RL/Base5ActionRLEnv.py b/freqtrade/freqai/RL/Base5ActionRLEnv.py
index 816211cc2..35d04f942 100644
--- a/freqtrade/freqai/RL/Base5ActionRLEnv.py
+++ b/freqtrade/freqai/RL/Base5ActionRLEnv.py
@@ -1,7 +1,7 @@
 import logging
 from enum import Enum
 
-from gym import spaces
+from gymnasium import spaces
 
 from freqtrade.freqai.RL.BaseEnvironment import BaseEnvironment, Positions
 
@@ -101,10 +101,12 @@ class Base5ActionRLEnv(BaseEnvironment):
         )
 
         observation = self._get_observation()
+        # user can play with time if they want
+        truncated = False
 
         self._update_history(info)
 
-        return observation, step_reward, self._done, info
+        return observation, step_reward, self._done, truncated, info
 
     def is_tradesignal(self, action: int) -> bool:
         """
diff --git a/freqtrade/freqai/RL/BaseEnvironment.py b/freqtrade/freqai/RL/BaseEnvironment.py
index 7ac77361c..42e644f0a 100644
--- a/freqtrade/freqai/RL/BaseEnvironment.py
+++ b/freqtrade/freqai/RL/BaseEnvironment.py
@@ -4,11 +4,11 @@ from abc import abstractmethod
 from enum import Enum
 from typing import Optional, Type, Union
 
-import gym
+import gymnasium as gym
 import numpy as np
 import pandas as pd
-from gym import spaces
-from gym.utils import seeding
+from gymnasium import spaces
+from gymnasium.utils import seeding
 from pandas import DataFrame
 
 
@@ -127,6 +127,14 @@ class BaseEnvironment(gym.Env):
         self.history: dict = {}
         self.trade_history: list = []
 
+    def get_attr(self, attr: str):
+        """
+        Returns the attribute of the environment
+        :param attr: attribute to return
+        :return: attribute
+        """
+        return getattr(self, attr)
+
     @abstractmethod
     def set_action_space(self):
         """
@@ -172,7 +180,7 @@ class BaseEnvironment(gym.Env):
     def reset_tensorboard_log(self):
         self.tensorboard_metrics = {}
 
-    def reset(self):
+    def reset(self, seed=None):
         """
         Reset is called at the beginning of every episode
         """
@@ -203,7 +211,7 @@ class BaseEnvironment(gym.Env):
         self.close_trade_profit = []
         self._total_unrealized_profit = 1
 
-        return self._get_observation()
+        return self._get_observation(), self.history
 
     @abstractmethod
     def step(self, action: int):
@@ -298,6 +306,12 @@ class BaseEnvironment(gym.Env):
         """
         An example reward function. This is the one function that users will likely
         wish to inject their own creativity into.
+
+        Warning!
+        This is function is a showcase of functionality designed to show as many possible
+        environment control features as possible. It is also designed to run quickly
+        on small computers. This is a benchmark, it is *not* for live production.
+
         :param action: int = The action made by the agent for the current candle.
         :return:
         float = the reward to give to the agent for current step (used for optimization
diff --git a/freqtrade/freqai/RL/BaseReinforcementLearningModel.py b/freqtrade/freqai/RL/BaseReinforcementLearningModel.py
index e10880f46..8ee3c7c56 100644
--- a/freqtrade/freqai/RL/BaseReinforcementLearningModel.py
+++ b/freqtrade/freqai/RL/BaseReinforcementLearningModel.py
@@ -6,7 +6,7 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Callable, Dict, Optional, Tuple, Type, Union
 
-import gym
+import gymnasium as gym
 import numpy as np
 import numpy.typing as npt
 import pandas as pd
@@ -16,14 +16,14 @@ from pandas import DataFrame
 from stable_baselines3.common.callbacks import EvalCallback
 from stable_baselines3.common.monitor import Monitor
 from stable_baselines3.common.utils import set_random_seed
-from stable_baselines3.common.vec_env import SubprocVecEnv
+from stable_baselines3.common.vec_env import SubprocVecEnv, VecMonitor
 
 from freqtrade.exceptions import OperationalException
 from freqtrade.freqai.data_kitchen import FreqaiDataKitchen
 from freqtrade.freqai.freqai_interface import IFreqaiModel
 from freqtrade.freqai.RL.Base5ActionRLEnv import Actions, Base5ActionRLEnv
-from freqtrade.freqai.RL.BaseEnvironment import BaseActions, Positions
-from freqtrade.freqai.RL.TensorboardCallback import TensorboardCallback
+from freqtrade.freqai.RL.BaseEnvironment import BaseActions, BaseEnvironment, Positions
+from freqtrade.freqai.tensorboard.TensorboardCallback import TensorboardCallback
 from freqtrade.persistence import Trade
 
 
@@ -46,8 +46,8 @@ class BaseReinforcementLearningModel(IFreqaiModel):
             'cpu_count', 1), max(int(self.max_system_threads / 2), 1))
         th.set_num_threads(self.max_threads)
         self.reward_params = self.freqai_info['rl_config']['model_reward_parameters']
-        self.train_env: Union[SubprocVecEnv, Type[gym.Env]] = gym.Env()
-        self.eval_env: Union[SubprocVecEnv, Type[gym.Env]] = gym.Env()
+        self.train_env: Union[VecMonitor, SubprocVecEnv, gym.Env] = gym.Env()
+        self.eval_env: Union[VecMonitor, SubprocVecEnv, gym.Env] = gym.Env()
         self.eval_callback: Optional[EvalCallback] = None
         self.model_type = self.freqai_info['rl_config']['model_type']
         self.rl_config = self.freqai_info['rl_config']
@@ -371,6 +371,12 @@ class BaseReinforcementLearningModel(IFreqaiModel):
             """
             An example reward function. This is the one function that users will likely
             wish to inject their own creativity into.
+
+            Warning!
+            This is function is a showcase of functionality designed to show as many possible
+            environment control features as possible. It is also designed to run quickly
+            on small computers. This is a benchmark, it is *not* for live production.
+
             :param action: int = The action made by the agent for the current candle.
             :return:
             float = the reward to give to the agent for current step (used for optimization
@@ -431,9 +437,8 @@ class BaseReinforcementLearningModel(IFreqaiModel):
             return 0.
 
 
-def make_env(MyRLEnv: Type[gym.Env], env_id: str, rank: int,
+def make_env(MyRLEnv: Type[BaseEnvironment], env_id: str, rank: int,
              seed: int, train_df: DataFrame, price: DataFrame,
-             monitor: bool = False,
              env_info: Dict[str, Any] = {}) -> Callable:
     """
     Utility function for multiprocessed env.
@@ -450,8 +455,7 @@ def make_env(MyRLEnv: Type[gym.Env], env_id: str, rank: int,
 
         env = MyRLEnv(df=train_df, prices=price, id=env_id, seed=seed + rank,
                       **env_info)
-        if monitor:
-            env = Monitor(env)
+
         return env
     set_random_seed(seed)
     return _init
diff --git a/freqtrade/freqai/base_models/BasePyTorchClassifier.py b/freqtrade/freqai/base_models/BasePyTorchClassifier.py
index 977152cc5..436294dcc 100644
--- a/freqtrade/freqai/base_models/BasePyTorchClassifier.py
+++ b/freqtrade/freqai/base_models/BasePyTorchClassifier.py
@@ -45,6 +45,7 @@ class BasePyTorchClassifier(BasePyTorchModel):
     ) -> Tuple[DataFrame, npt.NDArray[np.int_]]:
         """
         Filter the prediction features data and predict with it.
+        :param dk: dk: The datakitchen object
         :param unfiltered_df: Full dataframe for the current backtest period.
         :return:
         :pred_df: dataframe containing the predictions
@@ -74,11 +75,14 @@ class BasePyTorchClassifier(BasePyTorchModel):
             dk.data_dictionary["prediction_features"],
             device=self.device
         )
+        self.model.model.eval()
         logits = self.model.model(x)
         probs = F.softmax(logits, dim=-1)
         predicted_classes = torch.argmax(probs, dim=-1)
         predicted_classes_str = self.decode_class_names(predicted_classes)
-        pred_df_prob = DataFrame(probs.detach().numpy(), columns=class_names)
+        # used .tolist to convert probs into an iterable, in this way Tensors
+        # are automatically moved to the CPU first if necessary.
+        pred_df_prob = DataFrame(probs.detach().tolist(), columns=class_names)
         pred_df = DataFrame(predicted_classes_str, columns=[dk.label_list[0]])
         pred_df = pd.concat([pred_df, pred_df_prob], axis=1)
         return (pred_df, dk.do_predict)
diff --git a/freqtrade/freqai/base_models/BasePyTorchModel.py b/freqtrade/freqai/base_models/BasePyTorchModel.py
index 8177b8eb8..82042d24c 100644
--- a/freqtrade/freqai/base_models/BasePyTorchModel.py
+++ b/freqtrade/freqai/base_models/BasePyTorchModel.py
@@ -27,6 +27,7 @@ class BasePyTorchModel(IFreqaiModel, ABC):
         self.device = "cuda" if torch.cuda.is_available() else "cpu"
         test_size = self.freqai_info.get('data_split_parameters', {}).get('test_size')
         self.splits = ["train", "test"] if test_size != 0 else ["train"]
+        self.window_size = self.freqai_info.get("conv_width", 1)
 
     def train(
         self, unfiltered_df: DataFrame, pair: str, dk: FreqaiDataKitchen, **kwargs
diff --git a/freqtrade/freqai/base_models/BasePyTorchRegressor.py b/freqtrade/freqai/base_models/BasePyTorchRegressor.py
index ea6fabe49..6139f2e85 100644
--- a/freqtrade/freqai/base_models/BasePyTorchRegressor.py
+++ b/freqtrade/freqai/base_models/BasePyTorchRegressor.py
@@ -44,7 +44,8 @@ class BasePyTorchRegressor(BasePyTorchModel):
             dk.data_dictionary["prediction_features"],
             device=self.device
         )
+        self.model.model.eval()
         y = self.model.model(x)
-        y = y.cpu()
-        pred_df = DataFrame(y.detach().numpy(), columns=[dk.label_list[0]])
+        pred_df = DataFrame(y.detach().tolist(), columns=[dk.label_list[0]])
+        pred_df = dk.denormalize_labels_from_metadata(pred_df)
         return (pred_df, dk.do_predict)
diff --git a/freqtrade/freqai/freqai_interface.py b/freqtrade/freqai/freqai_interface.py
index 7eaaeab3e..9cfda05ee 100644
--- a/freqtrade/freqai/freqai_interface.py
+++ b/freqtrade/freqai/freqai_interface.py
@@ -21,7 +21,7 @@ from freqtrade.exceptions import OperationalException
 from freqtrade.exchange import timeframe_to_seconds
 from freqtrade.freqai.data_drawer import FreqaiDataDrawer
 from freqtrade.freqai.data_kitchen import FreqaiDataKitchen
-from freqtrade.freqai.utils import plot_feature_importance, record_params
+from freqtrade.freqai.utils import get_tb_logger, plot_feature_importance, record_params
 from freqtrade.strategy.interface import IStrategy
 
 
@@ -80,6 +80,7 @@ class IFreqaiModel(ABC):
         if self.keras and self.ft_params.get("DI_threshold", 0):
             self.ft_params["DI_threshold"] = 0
             logger.warning("DI threshold is not configured for Keras models yet. Deactivating.")
+
         self.CONV_WIDTH = self.freqai_info.get('conv_width', 1)
         if self.ft_params.get("inlier_metric_window", 0):
             self.CONV_WIDTH = self.ft_params.get("inlier_metric_window", 0) * 2
@@ -109,6 +110,7 @@ class IFreqaiModel(ABC):
         if self.ft_params.get('principal_component_analysis', False) and self.continual_learning:
             self.ft_params.update({'principal_component_analysis': False})
             logger.warning('User tried to use PCA with continual learning. Deactivating PCA.')
+        self.activate_tensorboard: bool = self.freqai_info.get('activate_tensorboard', True)
 
         record_params(config, self.full_path)
 
@@ -242,8 +244,8 @@ class IFreqaiModel(ABC):
                         new_trained_timerange, pair, strategy, dk, data_load_timerange
                     )
                 except Exception as msg:
-                    logger.warning(f"Training {pair} raised exception {msg.__class__.__name__}. "
-                                   f"Message: {msg}, skipping.")
+                    logger.exception(f"Training {pair} raised exception {msg.__class__.__name__}. "
+                                     f"Message: {msg}, skipping.")
 
                 self.train_timer('stop', pair)
 
@@ -306,10 +308,11 @@ class IFreqaiModel(ABC):
             if dk.check_if_backtest_prediction_is_valid(len_backtest_df):
                 if check_features:
                     self.dd.load_metadata(dk)
-                    dataframe_dummy_features = self.dk.use_strategy_to_populate_indicators(
+                    df_fts = self.dk.use_strategy_to_populate_indicators(
                         strategy, prediction_dataframe=dataframe.tail(1), pair=pair
                     )
-                    dk.find_features(dataframe_dummy_features)
+                    df_fts = dk.remove_special_chars_from_feature_names(df_fts)
+                    dk.find_features(df_fts)
                     self.check_if_feature_list_matches_strategy(dk)
                     check_features = False
                 append_df = dk.get_backtesting_prediction()
@@ -342,7 +345,10 @@ class IFreqaiModel(ABC):
                     dk.find_labels(dataframe_train)
 
                     try:
+                        self.tb_logger = get_tb_logger(self.dd.model_type, dk.data_path,
+                                                       self.activate_tensorboard)
                         self.model = self.train(dataframe_train, pair, dk)
+                        self.tb_logger.close()
                     except Exception as msg:
                         logger.warning(
                             f"Training {pair} raised exception {msg.__class__.__name__}. "
@@ -489,9 +495,9 @@ class IFreqaiModel(ABC):
         if dk.training_features_list != feature_list:
             raise OperationalException(
                 "Trying to access pretrained model with `identifier` "
-                "but found different features furnished by current strategy."
-                "Change `identifier` to train from scratch, or ensure the"
-                "strategy is furnishing the same features as the pretrained"
+                "but found different features furnished by current strategy. "
+                "Change `identifier` to train from scratch, or ensure the "
+                "strategy is furnishing the same features as the pretrained "
                 "model. In case of --strategy-list, please be aware that FreqAI "
                 "requires all strategies to maintain identical "
                 "feature_engineering_* functions"
@@ -620,18 +626,23 @@ class IFreqaiModel(ABC):
             strategy, corr_dataframes, base_dataframes, pair
         )
 
-        new_trained_timerange = dk.buffer_timerange(new_trained_timerange)
+        trained_timestamp = new_trained_timerange.stopts
 
-        unfiltered_dataframe = dk.slice_dataframe(new_trained_timerange, unfiltered_dataframe)
+        buffered_timerange = dk.buffer_timerange(new_trained_timerange)
+
+        unfiltered_dataframe = dk.slice_dataframe(buffered_timerange, unfiltered_dataframe)
 
         # find the features indicated by strategy and store in datakitchen
         dk.find_features(unfiltered_dataframe)
         dk.find_labels(unfiltered_dataframe)
 
+        self.tb_logger = get_tb_logger(self.dd.model_type, dk.data_path,
+                                       self.activate_tensorboard)
         model = self.train(unfiltered_dataframe, pair, dk)
+        self.tb_logger.close()
 
-        self.dd.pair_dict[pair]["trained_timestamp"] = new_trained_timerange.stopts
-        dk.set_new_model_names(pair, new_trained_timerange.stopts)
+        self.dd.pair_dict[pair]["trained_timestamp"] = trained_timestamp
+        dk.set_new_model_names(pair, trained_timestamp)
         self.dd.save_data(model, pair, dk)
 
         if self.plot_features:
diff --git a/freqtrade/freqai/prediction_models/PyTorchMLPClassifier.py b/freqtrade/freqai/prediction_models/PyTorchMLPClassifier.py
index ea7981405..71279dba9 100644
--- a/freqtrade/freqai/prediction_models/PyTorchMLPClassifier.py
+++ b/freqtrade/freqai/prediction_models/PyTorchMLPClassifier.py
@@ -74,16 +74,18 @@ class PyTorchMLPClassifier(BasePyTorchClassifier):
         model.to(self.device)
         optimizer = torch.optim.AdamW(model.parameters(), lr=self.learning_rate)
         criterion = torch.nn.CrossEntropyLoss()
-        init_model = self.get_init_model(dk.pair)
-        trainer = PyTorchModelTrainer(
-            model=model,
-            optimizer=optimizer,
-            criterion=criterion,
-            model_meta_data={"class_names": class_names},
-            device=self.device,
-            init_model=init_model,
-            data_convertor=self.data_convertor,
-            **self.trainer_kwargs,
-        )
+        # check if continual_learning is activated, and retreive the model to continue training
+        trainer = self.get_init_model(dk.pair)
+        if trainer is None:
+            trainer = PyTorchModelTrainer(
+                model=model,
+                optimizer=optimizer,
+                criterion=criterion,
+                model_meta_data={"class_names": class_names},
+                device=self.device,
+                data_convertor=self.data_convertor,
+                tb_logger=self.tb_logger,
+                **self.trainer_kwargs,
+            )
         trainer.fit(data_dictionary, self.splits)
         return trainer
diff --git a/freqtrade/freqai/prediction_models/PyTorchMLPRegressor.py b/freqtrade/freqai/prediction_models/PyTorchMLPRegressor.py
index 64f0f4b03..9f4534487 100644
--- a/freqtrade/freqai/prediction_models/PyTorchMLPRegressor.py
+++ b/freqtrade/freqai/prediction_models/PyTorchMLPRegressor.py
@@ -69,15 +69,17 @@ class PyTorchMLPRegressor(BasePyTorchRegressor):
         model.to(self.device)
         optimizer = torch.optim.AdamW(model.parameters(), lr=self.learning_rate)
         criterion = torch.nn.MSELoss()
-        init_model = self.get_init_model(dk.pair)
-        trainer = PyTorchModelTrainer(
-            model=model,
-            optimizer=optimizer,
-            criterion=criterion,
-            device=self.device,
-            init_model=init_model,
-            data_convertor=self.data_convertor,
-            **self.trainer_kwargs,
-        )
+        # check if continual_learning is activated, and retreive the model to continue training
+        trainer = self.get_init_model(dk.pair)
+        if trainer is None:
+            trainer = PyTorchModelTrainer(
+                model=model,
+                optimizer=optimizer,
+                criterion=criterion,
+                device=self.device,
+                data_convertor=self.data_convertor,
+                tb_logger=self.tb_logger,
+                **self.trainer_kwargs,
+            )
         trainer.fit(data_dictionary, self.splits)
         return trainer
diff --git a/freqtrade/freqai/prediction_models/PyTorchTransformerRegressor.py b/freqtrade/freqai/prediction_models/PyTorchTransformerRegressor.py
new file mode 100644
index 000000000..b3b684c14
--- /dev/null
+++ b/freqtrade/freqai/prediction_models/PyTorchTransformerRegressor.py
@@ -0,0 +1,140 @@
+from typing import Any, Dict, Tuple
+
+import numpy as np
+import numpy.typing as npt
+import pandas as pd
+import torch
+
+from freqtrade.freqai.base_models.BasePyTorchRegressor import BasePyTorchRegressor
+from freqtrade.freqai.data_kitchen import FreqaiDataKitchen
+from freqtrade.freqai.torch.PyTorchDataConvertor import (DefaultPyTorchDataConvertor,
+                                                         PyTorchDataConvertor)
+from freqtrade.freqai.torch.PyTorchModelTrainer import PyTorchTransformerTrainer
+from freqtrade.freqai.torch.PyTorchTransformerModel import PyTorchTransformerModel
+
+
+class PyTorchTransformerRegressor(BasePyTorchRegressor):
+    """
+    This class implements the fit method of IFreqaiModel.
+    in the fit method we initialize the model and trainer objects.
+    the only requirement from the model is to be aligned to PyTorchRegressor
+    predict method that expects the model to predict tensor of type float.
+    the trainer defines the training loop.
+
+    parameters are passed via `model_training_parameters` under the freqai
+    section in the config file. e.g:
+    {
+        ...
+        "freqai": {
+            ...
+            "model_training_parameters" : {
+                "learning_rate": 3e-4,
+                "trainer_kwargs": {
+                    "max_iters": 5000,
+                    "batch_size": 64,
+                    "max_n_eval_batches": null
+                },
+                "model_kwargs": {
+                    "hidden_dim": 512,
+                    "dropout_percent": 0.2,
+                    "n_layer": 1,
+                },
+            }
+        }
+    }
+    """
+
+    @property
+    def data_convertor(self) -> PyTorchDataConvertor:
+        return DefaultPyTorchDataConvertor(target_tensor_type=torch.float)
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        config = self.freqai_info.get("model_training_parameters", {})
+        self.learning_rate: float = config.get("learning_rate",  3e-4)
+        self.model_kwargs: Dict[str, Any] = config.get("model_kwargs",  {})
+        self.trainer_kwargs: Dict[str, Any] = config.get("trainer_kwargs",  {})
+
+    def fit(self, data_dictionary: Dict, dk: FreqaiDataKitchen, **kwargs) -> Any:
+        """
+        User sets up the training and test data to fit their desired model here
+        :param data_dictionary: the dictionary holding all data for train, test,
+            labels, weights
+        :param dk: The datakitchen object for the current coin/model
+        """
+
+        n_features = data_dictionary["train_features"].shape[-1]
+        n_labels = data_dictionary["train_labels"].shape[-1]
+        model = PyTorchTransformerModel(
+            input_dim=n_features,
+            output_dim=n_labels,
+            time_window=self.window_size,
+            **self.model_kwargs
+        )
+        model.to(self.device)
+        optimizer = torch.optim.AdamW(model.parameters(), lr=self.learning_rate)
+        criterion = torch.nn.MSELoss()
+        # check if continual_learning is activated, and retreive the model to continue training
+        trainer = self.get_init_model(dk.pair)
+        if trainer is None:
+            trainer = PyTorchTransformerTrainer(
+                model=model,
+                optimizer=optimizer,
+                criterion=criterion,
+                device=self.device,
+                data_convertor=self.data_convertor,
+                window_size=self.window_size,
+                tb_logger=self.tb_logger,
+                **self.trainer_kwargs,
+            )
+        trainer.fit(data_dictionary, self.splits)
+        return trainer
+
+    def predict(
+        self, unfiltered_df: pd.DataFrame, dk: FreqaiDataKitchen, **kwargs
+    ) -> Tuple[pd.DataFrame, npt.NDArray[np.int_]]:
+        """
+        Filter the prediction features data and predict with it.
+        :param unfiltered_df: Full dataframe for the current backtest period.
+        :return:
+        :pred_df: dataframe containing the predictions
+        :do_predict: np.array of 1s and 0s to indicate places where freqai needed to remove
+        data (NaNs) or felt uncertain about data (PCA and DI index)
+        """
+
+        dk.find_features(unfiltered_df)
+        filtered_df, _ = dk.filter_features(
+            unfiltered_df, dk.training_features_list, training_filter=False
+        )
+        filtered_df = dk.normalize_data_from_metadata(filtered_df)
+        dk.data_dictionary["prediction_features"] = filtered_df
+
+        self.data_cleaning_predict(dk)
+        x = self.data_convertor.convert_x(
+            dk.data_dictionary["prediction_features"],
+            device=self.device
+        )
+        # if user is asking for multiple predictions, slide the window
+        # along the tensor
+        x = x.unsqueeze(0)
+        # create empty torch tensor
+        self.model.model.eval()
+        yb = torch.empty(0).to(self.device)
+        if x.shape[1] > 1:
+            ws = self.window_size
+            for i in range(0, x.shape[1] - ws):
+                xb = x[:, i:i + ws, :].to(self.device)
+                y = self.model.model(xb)
+                yb = torch.cat((yb, y), dim=0)
+        else:
+            yb = self.model.model(x)
+
+        yb = yb.cpu().squeeze()
+        pred_df = pd.DataFrame(yb.detach().numpy(), columns=dk.label_list)
+        pred_df = dk.denormalize_labels_from_metadata(pred_df)
+
+        if x.shape[1] > 1:
+            zeros_df = pd.DataFrame(np.zeros((x.shape[1] - len(pred_df), len(pred_df.columns))),
+                                    columns=pred_df.columns)
+            pred_df = pd.concat([zeros_df, pred_df], axis=0, ignore_index=True)
+        return (pred_df, dk.do_predict)
diff --git a/freqtrade/freqai/prediction_models/ReinforcementLearner.py b/freqtrade/freqai/prediction_models/ReinforcementLearner.py
index 65990da87..a11decc92 100644
--- a/freqtrade/freqai/prediction_models/ReinforcementLearner.py
+++ b/freqtrade/freqai/prediction_models/ReinforcementLearner.py
@@ -1,11 +1,12 @@
 import logging
 from pathlib import Path
-from typing import Any, Dict
+from typing import Any, Dict, Type
 
 import torch as th
 
 from freqtrade.freqai.data_kitchen import FreqaiDataKitchen
 from freqtrade.freqai.RL.Base5ActionRLEnv import Actions, Base5ActionRLEnv, Positions
+from freqtrade.freqai.RL.BaseEnvironment import BaseEnvironment
 from freqtrade.freqai.RL.BaseReinforcementLearningModel import BaseReinforcementLearningModel
 
 
@@ -57,10 +58,14 @@ class ReinforcementLearner(BaseReinforcementLearningModel):
         policy_kwargs = dict(activation_fn=th.nn.ReLU,
                              net_arch=self.net_arch)
 
+        if self.activate_tensorboard:
+            tb_path = Path(dk.full_path / "tensorboard" / dk.pair.split('/')[0])
+        else:
+            tb_path = None
+
         if dk.pair not in self.dd.model_dictionary or not self.continual_learning:
             model = self.MODELCLASS(self.policy_type, self.train_env, policy_kwargs=policy_kwargs,
-                                    tensorboard_log=Path(
-                                        dk.full_path / "tensorboard" / dk.pair.split('/')[0]),
+                                    tensorboard_log=tb_path,
                                     **self.freqai_info.get('model_training_parameters', {})
                                     )
         else:
@@ -84,7 +89,9 @@ class ReinforcementLearner(BaseReinforcementLearningModel):
 
         return model
 
-    class MyRLEnv(Base5ActionRLEnv):
+    MyRLEnv: Type[BaseEnvironment]
+
+    class MyRLEnv(Base5ActionRLEnv):  # type: ignore[no-redef]
         """
         User can override any function in BaseRLEnv and gym.Env. Here the user
         sets a custom reward based on profit and trade duration.
@@ -94,6 +101,12 @@ class ReinforcementLearner(BaseReinforcementLearningModel):
             """
             An example reward function. This is the one function that users will likely
             wish to inject their own creativity into.
+
+                        Warning!
+            This is function is a showcase of functionality designed to show as many possible
+            environment control features as possible. It is also designed to run quickly
+            on small computers. This is a benchmark, it is *not* for live production.
+
             :param action: int = The action made by the agent for the current candle.
             :return:
             float = the reward to give to the agent for current step (used for optimization
diff --git a/freqtrade/freqai/prediction_models/ReinforcementLearner_multiproc.py b/freqtrade/freqai/prediction_models/ReinforcementLearner_multiproc.py
index b3b8c40e6..9f0b2d436 100644
--- a/freqtrade/freqai/prediction_models/ReinforcementLearner_multiproc.py
+++ b/freqtrade/freqai/prediction_models/ReinforcementLearner_multiproc.py
@@ -3,12 +3,12 @@ from typing import Any, Dict
 
 from pandas import DataFrame
 from stable_baselines3.common.callbacks import EvalCallback
-from stable_baselines3.common.vec_env import SubprocVecEnv
+from stable_baselines3.common.vec_env import SubprocVecEnv, VecMonitor
 
 from freqtrade.freqai.data_kitchen import FreqaiDataKitchen
 from freqtrade.freqai.prediction_models.ReinforcementLearner import ReinforcementLearner
 from freqtrade.freqai.RL.BaseReinforcementLearningModel import make_env
-from freqtrade.freqai.RL.TensorboardCallback import TensorboardCallback
+from freqtrade.freqai.tensorboard.TensorboardCallback import TensorboardCallback
 
 
 logger = logging.getLogger(__name__)
@@ -41,22 +41,25 @@ class ReinforcementLearner_multiproc(ReinforcementLearner):
 
         env_info = self.pack_env_dict(dk.pair)
 
+        eval_freq = len(train_df) // self.max_threads
+
         env_id = "train_env"
-        self.train_env = SubprocVecEnv([make_env(self.MyRLEnv, env_id, i, 1,
-                                        train_df, prices_train,
-                                        monitor=True,
-                                        env_info=env_info) for i
-                                        in range(self.max_threads)])
+        self.train_env = VecMonitor(SubprocVecEnv([make_env(self.MyRLEnv, env_id, i, 1,
+                                                            train_df, prices_train,
+                                                            env_info=env_info) for i
+                                                   in range(self.max_threads)]))
 
         eval_env_id = 'eval_env'
-        self.eval_env = SubprocVecEnv([make_env(self.MyRLEnv, eval_env_id, i, 1,
-                                                test_df, prices_test,
-                                                monitor=True,
-                                                env_info=env_info) for i
-                                       in range(self.max_threads)])
+        self.eval_env = VecMonitor(SubprocVecEnv([make_env(self.MyRLEnv, eval_env_id, i, 1,
+                                                           test_df, prices_test,
+                                                           env_info=env_info) for i
+                                                  in range(self.max_threads)]))
+
         self.eval_callback = EvalCallback(self.eval_env, deterministic=True,
-                                          render=False, eval_freq=len(train_df),
+                                          render=False, eval_freq=eval_freq,
                                           best_model_save_path=str(dk.data_path))
 
+        # TENSORBOARD CALLBACK DOES NOT RECOMMENDED TO USE WITH MULTIPLE ENVS,
+        # IT WILL RETURN FALSE INFORMATIONS, NEVERTHLESS NOT THREAD SAFE WITH SB3!!!
         actions = self.train_env.env_method("get_actions")[0]
         self.tensorboard_callback = TensorboardCallback(verbose=1, actions=actions)
diff --git a/freqtrade/freqai/prediction_models/XGBoostRegressor.py b/freqtrade/freqai/prediction_models/XGBoostRegressor.py
index 93dfb319e..f8b4d353d 100644
--- a/freqtrade/freqai/prediction_models/XGBoostRegressor.py
+++ b/freqtrade/freqai/prediction_models/XGBoostRegressor.py
@@ -5,6 +5,7 @@ from xgboost import XGBRegressor
 
 from freqtrade.freqai.base_models.BaseRegressionModel import BaseRegressionModel
 from freqtrade.freqai.data_kitchen import FreqaiDataKitchen
+from freqtrade.freqai.tensorboard import TBCallback
 
 
 logger = logging.getLogger(__name__)
@@ -44,7 +45,10 @@ class XGBoostRegressor(BaseRegressionModel):
 
         model = XGBRegressor(**self.model_training_parameters)
 
+        model.set_params(callbacks=[TBCallback(dk.data_path)], activate=self.activate_tensorboard)
         model.fit(X=X, y=y, sample_weight=sample_weight, eval_set=eval_set,
                   sample_weight_eval_set=eval_weights, xgb_model=xgb_model)
+        # set the callbacks to empty so that we can serialize to disk later
+        model.set_params(callbacks=[])
 
         return model
diff --git a/freqtrade/freqai/RL/TensorboardCallback.py b/freqtrade/freqai/tensorboard/TensorboardCallback.py
similarity index 85%
rename from freqtrade/freqai/RL/TensorboardCallback.py
rename to freqtrade/freqai/tensorboard/TensorboardCallback.py
index 7f8c76956..61652c9c6 100644
--- a/freqtrade/freqai/RL/TensorboardCallback.py
+++ b/freqtrade/freqai/tensorboard/TensorboardCallback.py
@@ -3,8 +3,9 @@ from typing import Any, Dict, Type, Union
 
 from stable_baselines3.common.callbacks import BaseCallback
 from stable_baselines3.common.logger import HParam
+from stable_baselines3.common.vec_env import VecEnv
 
-from freqtrade.freqai.RL.BaseEnvironment import BaseActions, BaseEnvironment
+from freqtrade.freqai.RL.BaseEnvironment import BaseActions
 
 
 class TensorboardCallback(BaseCallback):
@@ -12,11 +13,13 @@ class TensorboardCallback(BaseCallback):
     Custom callback for plotting additional values in tensorboard and
     episodic summary reports.
     """
+    # Override training_env type to fix type errors
+    training_env: Union[VecEnv, None] = None
+
     def __init__(self, verbose=1, actions: Type[Enum] = BaseActions):
         super().__init__(verbose)
         self.model: Any = None
-        self.logger = None  # type: Any
-        self.training_env: BaseEnvironment = None  # type: ignore
+        self.logger: Any = None
         self.actions: Type[Enum] = actions
 
     def _on_training_start(self) -> None:
@@ -44,6 +47,8 @@ class TensorboardCallback(BaseCallback):
     def _on_step(self) -> bool:
 
         local_info = self.locals["infos"][0]
+        if self.training_env is None:
+            return True
         tensorboard_metrics = self.training_env.get_attr("tensorboard_metrics")[0]
 
         for metric in local_info:
diff --git a/freqtrade/freqai/tensorboard/__init__.py b/freqtrade/freqai/tensorboard/__init__.py
new file mode 100644
index 000000000..59862bc0d
--- /dev/null
+++ b/freqtrade/freqai/tensorboard/__init__.py
@@ -0,0 +1,15 @@
+# ensure users can still use a non-torch freqai version
+try:
+    from freqtrade.freqai.tensorboard.tensorboard import TensorBoardCallback, TensorboardLogger
+    TBLogger = TensorboardLogger
+    TBCallback = TensorBoardCallback
+except ModuleNotFoundError:
+    from freqtrade.freqai.tensorboard.base_tensorboard import (BaseTensorBoardCallback,
+                                                               BaseTensorboardLogger)
+    TBLogger = BaseTensorboardLogger  # type: ignore
+    TBCallback = BaseTensorBoardCallback  # type: ignore
+
+__all__ = (
+    "TBLogger",
+    "TBCallback"
+)
diff --git a/freqtrade/freqai/tensorboard/base_tensorboard.py b/freqtrade/freqai/tensorboard/base_tensorboard.py
new file mode 100644
index 000000000..72f47111c
--- /dev/null
+++ b/freqtrade/freqai/tensorboard/base_tensorboard.py
@@ -0,0 +1,33 @@
+import logging
+from pathlib import Path
+from typing import Any
+
+from xgboost.callback import TrainingCallback
+
+
+logger = logging.getLogger(__name__)
+
+
+class BaseTensorboardLogger:
+    def __init__(self, logdir: Path, activate: bool = True):
+        pass
+
+    def log_scalar(self, tag: str, scalar_value: Any, step: int):
+        return
+
+    def close(self):
+        return
+
+
+class BaseTensorBoardCallback(TrainingCallback):
+
+    def __init__(self, logdir: Path, activate: bool = True):
+        pass
+
+    def after_iteration(
+        self, model, epoch: int, evals_log: TrainingCallback.EvalsLog
+    ) -> bool:
+        return False
+
+    def after_training(self, model):
+        return model
diff --git a/freqtrade/freqai/tensorboard/tensorboard.py b/freqtrade/freqai/tensorboard/tensorboard.py
new file mode 100644
index 000000000..46bf8dc61
--- /dev/null
+++ b/freqtrade/freqai/tensorboard/tensorboard.py
@@ -0,0 +1,62 @@
+import logging
+from pathlib import Path
+from typing import Any
+
+from torch.utils.tensorboard import SummaryWriter
+from xgboost import callback
+
+from freqtrade.freqai.tensorboard.base_tensorboard import (BaseTensorBoardCallback,
+                                                           BaseTensorboardLogger)
+
+
+logger = logging.getLogger(__name__)
+
+
+class TensorboardLogger(BaseTensorboardLogger):
+    def __init__(self, logdir: Path, activate: bool = True):
+        self.activate = activate
+        if self.activate:
+            self.writer: SummaryWriter = SummaryWriter(f"{str(logdir)}/tensorboard")
+
+    def log_scalar(self, tag: str, scalar_value: Any, step: int):
+        if self.activate:
+            self.writer.add_scalar(tag, scalar_value, step)
+
+    def close(self):
+        if self.activate:
+            self.writer.flush()
+            self.writer.close()
+
+
+class TensorBoardCallback(BaseTensorBoardCallback):
+
+    def __init__(self, logdir: Path, activate: bool = True):
+        self.activate = activate
+        if self.activate:
+            self.writer: SummaryWriter = SummaryWriter(f"{str(logdir)}/tensorboard")
+
+    def after_iteration(
+        self, model, epoch: int, evals_log: callback.TrainingCallback.EvalsLog
+    ) -> bool:
+        if not self.activate:
+            return False
+        if not evals_log:
+            return False
+
+        for data, metric in evals_log.items():
+            for metric_name, log in metric.items():
+                score = log[-1][0] if isinstance(log[-1], tuple) else log[-1]
+                if data == "train":
+                    self.writer.add_scalar("train_loss", score, epoch)
+                else:
+                    self.writer.add_scalar("valid_loss", score, epoch)
+
+        return False
+
+    def after_training(self, model):
+        if not self.activate:
+            return model
+        self.writer.flush()
+        self.writer.close()
+
+        return model
diff --git a/freqtrade/freqai/torch/PyTorchDataConvertor.py b/freqtrade/freqai/torch/PyTorchDataConvertor.py
index a31ccdc79..e6b815373 100644
--- a/freqtrade/freqai/torch/PyTorchDataConvertor.py
+++ b/freqtrade/freqai/torch/PyTorchDataConvertor.py
@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import List, Optional
+from typing import Optional
 
 import pandas as pd
 import torch
@@ -12,14 +12,14 @@ class PyTorchDataConvertor(ABC):
     """
 
     @abstractmethod
-    def convert_x(self, df: pd.DataFrame, device: Optional[str] = None) -> List[torch.Tensor]:
+    def convert_x(self, df: pd.DataFrame, device: Optional[str] = None) -> torch.Tensor:
         """
         :param df: "*_features" dataframe.
         :param device: The device to use for training (e.g. 'cpu', 'cuda').
         """
 
     @abstractmethod
-    def convert_y(self, df: pd.DataFrame, device: Optional[str] = None) -> List[torch.Tensor]:
+    def convert_y(self, df: pd.DataFrame, device: Optional[str] = None) -> torch.Tensor:
         """
         :param df: "*_labels" dataframe.
         :param device: The device to use for training (e.g. 'cpu', 'cuda').
@@ -45,14 +45,14 @@ class DefaultPyTorchDataConvertor(PyTorchDataConvertor):
         self._target_tensor_type = target_tensor_type
         self._squeeze_target_tensor = squeeze_target_tensor
 
-    def convert_x(self, df: pd.DataFrame, device: Optional[str] = None) -> List[torch.Tensor]:
+    def convert_x(self, df: pd.DataFrame, device: Optional[str] = None) -> torch.Tensor:
         x = torch.from_numpy(df.values).float()
         if device:
             x = x.to(device)
 
-        return [x]
+        return x
 
-    def convert_y(self, df: pd.DataFrame, device: Optional[str] = None) -> List[torch.Tensor]:
+    def convert_y(self, df: pd.DataFrame, device: Optional[str] = None) -> torch.Tensor:
         y = torch.from_numpy(df.values)
 
         if self._target_tensor_type:
@@ -64,4 +64,4 @@ class DefaultPyTorchDataConvertor(PyTorchDataConvertor):
         if device:
             y = y.to(device)
 
-        return [y]
+        return y
diff --git a/freqtrade/freqai/torch/PyTorchMLPModel.py b/freqtrade/freqai/torch/PyTorchMLPModel.py
index 62d3216df..0093388f8 100644
--- a/freqtrade/freqai/torch/PyTorchMLPModel.py
+++ b/freqtrade/freqai/torch/PyTorchMLPModel.py
@@ -1,5 +1,4 @@
 import logging
-from typing import List
 
 import torch
 from torch import nn
@@ -47,8 +46,8 @@ class PyTorchMLPModel(nn.Module):
         self.relu = nn.ReLU()
         self.dropout = nn.Dropout(p=dropout_percent)
 
-    def forward(self, tensors: List[torch.Tensor]) -> torch.Tensor:
-        x: torch.Tensor = tensors[0]
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        # x: torch.Tensor = tensors[0]
         x = self.relu(self.input_layer(x))
         x = self.dropout(x)
         x = self.blocks(x)
diff --git a/freqtrade/freqai/torch/PyTorchModelTrainer.py b/freqtrade/freqai/torch/PyTorchModelTrainer.py
index 8277ba937..603e7ac12 100644
--- a/freqtrade/freqai/torch/PyTorchModelTrainer.py
+++ b/freqtrade/freqai/torch/PyTorchModelTrainer.py
@@ -12,6 +12,8 @@ from torch.utils.data import DataLoader, TensorDataset
 from freqtrade.freqai.torch.PyTorchDataConvertor import PyTorchDataConvertor
 from freqtrade.freqai.torch.PyTorchTrainerInterface import PyTorchTrainerInterface
 
+from .datasets import WindowDataset
+
 
 logger = logging.getLogger(__name__)
 
@@ -23,9 +25,10 @@ class PyTorchModelTrainer(PyTorchTrainerInterface):
             optimizer: Optimizer,
             criterion: nn.Module,
             device: str,
-            init_model: Dict,
             data_convertor: PyTorchDataConvertor,
             model_meta_data: Dict[str, Any] = {},
+            window_size: int = 1,
+            tb_logger: Any = None,
             **kwargs
     ):
         """
@@ -52,8 +55,8 @@ class PyTorchModelTrainer(PyTorchTrainerInterface):
         self.batch_size: int = kwargs.get("batch_size", 64)
         self.max_n_eval_batches: Optional[int] = kwargs.get("max_n_eval_batches", None)
         self.data_convertor = data_convertor
-        if init_model:
-            self.load_from_checkpoint(init_model)
+        self.window_size: int = window_size
+        self.tb_logger = tb_logger
 
     def fit(self, data_dictionary: Dict[str, pd.DataFrame], splits: List[str]):
         """
@@ -75,36 +78,28 @@ class PyTorchModelTrainer(PyTorchTrainerInterface):
             batch_size=self.batch_size,
             n_iters=self.max_iters
         )
+        self.model.train()
         for epoch in range(1, epochs + 1):
-            # training
-            losses = []
             for i, batch_data in enumerate(data_loaders_dictionary["train"]):
 
-                for tensor in batch_data:
-                    tensor.to(self.device)
-
-                xb = batch_data[:-1]
-                yb = batch_data[-1]
+                xb, yb = batch_data
+                xb.to(self.device)
+                yb.to(self.device)
                 yb_pred = self.model(xb)
                 loss = self.criterion(yb_pred, yb)
 
                 self.optimizer.zero_grad(set_to_none=True)
                 loss.backward()
                 self.optimizer.step()
-                losses.append(loss.item())
-            train_loss = sum(losses) / len(losses)
-            log_message = f"epoch {epoch}/{epochs}: train loss {train_loss:.4f}"
+                self.tb_logger.log_scalar("train_loss", loss.item(), i)
 
             # evaluation
             if "test" in splits:
-                test_loss = self.estimate_loss(
+                self.estimate_loss(
                     data_loaders_dictionary,
                     self.max_n_eval_batches,
                     "test"
                 )
-                log_message += f" ; test loss {test_loss:.4f}"
-
-            logger.info(log_message)
 
     @torch.no_grad()
     def estimate_loss(
@@ -112,26 +107,22 @@ class PyTorchModelTrainer(PyTorchTrainerInterface):
             data_loader_dictionary: Dict[str, DataLoader],
             max_n_eval_batches: Optional[int],
             split: str,
-    ) -> float:
+    ) -> None:
         self.model.eval()
         n_batches = 0
-        losses = []
         for i, batch_data in enumerate(data_loader_dictionary[split]):
             if max_n_eval_batches and i > max_n_eval_batches:
                 n_batches += 1
                 break
+            xb, yb = batch_data
+            xb.to(self.device)
+            yb.to(self.device)
 
-            for tensor in batch_data:
-                tensor.to(self.device)
-
-            xb = batch_data[:-1]
-            yb = batch_data[-1]
             yb_pred = self.model(xb)
             loss = self.criterion(yb_pred, yb)
-            losses.append(loss.item())
+            self.tb_logger.log_scalar(f"{split}_loss", loss.item(), i)
 
         self.model.train()
-        return sum(losses) / len(losses)
 
     def create_data_loaders_dictionary(
             self,
@@ -145,7 +136,7 @@ class PyTorchModelTrainer(PyTorchTrainerInterface):
         for split in splits:
             x = self.data_convertor.convert_x(data_dictionary[f"{split}_features"], self.device)
             y = self.data_convertor.convert_y(data_dictionary[f"{split}_labels"], self.device)
-            dataset = TensorDataset(*x, *y)
+            dataset = TensorDataset(x, y)
             data_loader = DataLoader(
                 dataset,
                 batch_size=self.batch_size,
@@ -206,3 +197,33 @@ class PyTorchModelTrainer(PyTorchTrainerInterface):
         self.optimizer.load_state_dict(checkpoint["optimizer_state_dict"])
         self.model_meta_data = checkpoint["model_meta_data"]
         return self
+
+
+class PyTorchTransformerTrainer(PyTorchModelTrainer):
+    """
+    Creating a trainer for the Transformer model.
+    """
+
+    def create_data_loaders_dictionary(
+            self,
+            data_dictionary: Dict[str, pd.DataFrame],
+            splits: List[str]
+    ) -> Dict[str, DataLoader]:
+        """
+        Converts the input data to PyTorch tensors using a data loader.
+        """
+        data_loader_dictionary = {}
+        for split in splits:
+            x = self.data_convertor.convert_x(data_dictionary[f"{split}_features"], self.device)
+            y = self.data_convertor.convert_y(data_dictionary[f"{split}_labels"], self.device)
+            dataset = WindowDataset(x, y, self.window_size)
+            data_loader = DataLoader(
+                dataset,
+                batch_size=self.batch_size,
+                shuffle=False,
+                drop_last=True,
+                num_workers=0,
+            )
+            data_loader_dictionary[split] = data_loader
+
+        return data_loader_dictionary
diff --git a/freqtrade/freqai/torch/PyTorchTransformerModel.py b/freqtrade/freqai/torch/PyTorchTransformerModel.py
new file mode 100644
index 000000000..162459776
--- /dev/null
+++ b/freqtrade/freqai/torch/PyTorchTransformerModel.py
@@ -0,0 +1,93 @@
+import math
+
+import torch
+from torch import nn
+
+
+"""
+The architecture is based on the paper “Attention Is All You Need”.
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez,
+Lukasz Kaiser, and Illia Polosukhin. 2017.
+"""
+
+
+class PyTorchTransformerModel(nn.Module):
+    """
+    A transformer approach to time series modeling using positional encoding.
+    The architecture is based on the paper “Attention Is All You Need”.
+    Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez,
+    Lukasz Kaiser, and Illia Polosukhin. 2017.
+    """
+
+    def __init__(self, input_dim: int = 7, output_dim: int = 7, hidden_dim=1024,
+                 n_layer=2, dropout_percent=0.1, time_window=10, nhead=8):
+        super().__init__()
+        self.time_window = time_window
+        # ensure the input dimension to the transformer is divisible by nhead
+        self.dim_val = input_dim - (input_dim % nhead)
+        self.input_net = nn.Sequential(
+            nn.Dropout(dropout_percent), nn.Linear(input_dim, self.dim_val)
+        )
+
+        # Encode the timeseries with Positional encoding
+        self.positional_encoding = PositionalEncoding(d_model=self.dim_val, max_len=self.dim_val)
+
+        # Define the encoder block of the Transformer
+        self.encoder_layer = nn.TransformerEncoderLayer(
+            d_model=self.dim_val, nhead=nhead, dropout=dropout_percent, batch_first=True)
+        self.transformer = nn.TransformerEncoder(self.encoder_layer, num_layers=n_layer)
+
+        # the pseudo decoding FC
+        self.output_net = nn.Sequential(
+            nn.Linear(self.dim_val * time_window, int(hidden_dim)),
+            nn.ReLU(),
+            nn.Dropout(dropout_percent),
+            nn.Linear(int(hidden_dim), int(hidden_dim / 2)),
+            nn.ReLU(),
+            nn.Dropout(dropout_percent),
+            nn.Linear(int(hidden_dim / 2), int(hidden_dim / 4)),
+            nn.ReLU(),
+            nn.Dropout(dropout_percent),
+            nn.Linear(int(hidden_dim / 4), output_dim)
+        )
+
+    def forward(self, x, mask=None, add_positional_encoding=True):
+        """
+        Args:
+            x: Input features of shape [Batch, SeqLen, input_dim]
+            mask: Mask to apply on the attention outputs (optional)
+            add_positional_encoding: If True, we add the positional encoding to the input.
+                                      Might not be desired for some tasks.
+        """
+        x = self.input_net(x)
+        if add_positional_encoding:
+            x = self.positional_encoding(x)
+        x = self.transformer(x, mask=mask)
+        x = x.reshape(-1, 1, self.time_window * x.shape[-1])
+        x = self.output_net(x)
+        return x
+
+
+class PositionalEncoding(nn.Module):
+    def __init__(self, d_model, max_len=5000):
+        """
+        Args
+            d_model: Hidden dimensionality of the input.
+            max_len: Maximum length of a sequence to expect.
+        """
+        super().__init__()
+
+        # Create matrix of [SeqLen, HiddenDim] representing the positional encoding
+        # for max_len inputs
+        pe = torch.zeros(max_len, d_model)
+        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
+        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
+        pe[:, 0::2] = torch.sin(position * div_term)
+        pe[:, 1::2] = torch.cos(position * div_term)
+        pe = pe.unsqueeze(0)
+
+        self.register_buffer("pe", pe, persistent=False)
+
+    def forward(self, x):
+        x = x + self.pe[:, : x.size(1)]
+        return x
diff --git a/freqtrade/freqai/torch/datasets.py b/freqtrade/freqai/torch/datasets.py
new file mode 100644
index 000000000..120d8a116
--- /dev/null
+++ b/freqtrade/freqai/torch/datasets.py
@@ -0,0 +1,19 @@
+import torch
+
+
+class WindowDataset(torch.utils.data.Dataset):
+    def __init__(self, xs, ys, window_size):
+        self.xs = xs
+        self.ys = ys
+        self.window_size = window_size
+
+    def __len__(self):
+        return len(self.xs) - self.window_size
+
+    def __getitem__(self, index):
+        idx_rev = len(self.xs) - self.window_size - index - 1
+        window_x = self.xs[idx_rev:idx_rev + self.window_size, :]
+        # Beware of indexing, these two window_x and window_y are aimed at the same row!
+        # this is what happens when you use :
+        window_y = self.ys[idx_rev + self.window_size - 1, :].unsqueeze(0)
+        return window_x, window_y
diff --git a/freqtrade/freqai/utils.py b/freqtrade/freqai/utils.py
index 2ba49ac40..b670a2aad 100644
--- a/freqtrade/freqai/utils.py
+++ b/freqtrade/freqai/utils.py
@@ -92,55 +92,6 @@ def get_required_data_timerange(config: Config) -> TimeRange:
     return data_load_timerange
 
 
-# Keep below for when we wish to download heterogeneously lengthed data for FreqAI.
-# def download_all_data_for_training(dp: DataProvider, config: Config) -> None:
-#     """
-#     Called only once upon start of bot to download the necessary data for
-#     populating indicators and training a FreqAI model.
-#     :param timerange: TimeRange = The full data timerange for populating the indicators
-#                                     and training the model.
-#     :param dp: DataProvider instance attached to the strategy
-#     """
-
-#     if dp._exchange is not None:
-#         markets = [p for p, m in dp._exchange.markets.items() if market_is_active(m)
-#                    or config.get('include_inactive')]
-#     else:
-#         # This should not occur:
-#         raise OperationalException('No exchange object found.')
-
-#     all_pairs = dynamic_expand_pairlist(config, markets)
-
-#     if not dp._exchange:
-#         # Not realistic - this is only called in live mode.
-#         raise OperationalException("Dataprovider did not have an exchange attached.")
-
-#     time = datetime.now(tz=timezone.utc).timestamp()
-
-#     for tf in config["freqai"]["feature_parameters"].get("include_timeframes"):
-#         timerange = TimeRange()
-#         timerange.startts = int(time)
-#         timerange.stopts = int(time)
-#         startup_candles = dp.get_required_startup(str(tf))
-#         tf_seconds = timeframe_to_seconds(str(tf))
-#         timerange.subtract_start(tf_seconds * startup_candles)
-#         new_pairs_days = int((timerange.stopts - timerange.startts) / 86400)
-#         # FIXME: now that we are looping on `refresh_backtest_ohlcv_data`, the function
-#         # redownloads the funding rate for each pair.
-#         refresh_backtest_ohlcv_data(
-#             dp._exchange,
-#             pairs=all_pairs,
-#             timeframes=[tf],
-#             datadir=config["datadir"],
-#             timerange=timerange,
-#             new_pairs_days=new_pairs_days,
-#             erase=False,
-#             data_format=config.get("dataformat_ohlcv", "json"),
-#             trading_mode=config.get("trading_mode", "spot"),
-#             prepend=config.get("prepend_data", False),
-#         )
-
-
 def plot_feature_importance(model: Any, pair: str, dk: FreqaiDataKitchen,
                             count_max: int = 25) -> None:
     """
@@ -233,3 +184,13 @@ def get_timerange_backtest_live_models(config: Config) -> str:
     dd = FreqaiDataDrawer(models_path, config)
     timerange = dd.get_timerange_from_live_historic_predictions()
     return timerange.timerange_str
+
+
+def get_tb_logger(model_type: str, path: Path, activate: bool) -> Any:
+
+    if model_type == "pytorch" and activate:
+        from freqtrade.freqai.tensorboard import TBLogger
+        return TBLogger(path, activate)
+    else:
+        from freqtrade.freqai.tensorboard.base_tensorboard import BaseTensorboardLogger
+        return BaseTensorboardLogger(path, activate)
diff --git a/freqtrade/freqtradebot.py b/freqtrade/freqtradebot.py
index 9cc26ad77..fc4c65caf 100644
--- a/freqtrade/freqtradebot.py
+++ b/freqtrade/freqtradebot.py
@@ -1,9 +1,9 @@
 """
 Freqtrade is the main module of this bot. It contains the class Freqtrade()
 """
-import copy
 import logging
 import traceback
+from copy import deepcopy
 from datetime import datetime, time, timedelta, timezone
 from math import isclose
 from threading import Lock
@@ -13,7 +13,7 @@ from schedule import Scheduler
 
 from freqtrade import constants
 from freqtrade.configuration import validate_config_consistency
-from freqtrade.constants import BuySell, Config, LongShort
+from freqtrade.constants import BuySell, Config, ExchangeConfig, LongShort
 from freqtrade.data.converter import order_book_to_dataframe
 from freqtrade.data.dataprovider import DataProvider
 from freqtrade.edge import Edge
@@ -23,6 +23,7 @@ from freqtrade.exceptions import (DependencyException, ExchangeError, Insufficie
                                   InvalidOrderException, PricingError)
 from freqtrade.exchange import (ROUND_DOWN, ROUND_UP, timeframe_to_minutes, timeframe_to_next_date,
                                 timeframe_to_seconds)
+from freqtrade.exchange.common import remove_exchange_credentials
 from freqtrade.misc import safe_value_fallback, safe_value_fallback2
 from freqtrade.mixins import LoggingMixin
 from freqtrade.persistence import Order, PairLocks, Trade, init_db
@@ -63,6 +64,9 @@ class FreqtradeBot(LoggingMixin):
 
         # Init objects
         self.config = config
+        exchange_config: ExchangeConfig = deepcopy(config['exchange'])
+        # Remove credentials from original exchange config to avoid accidental credentail exposure
+        remove_exchange_credentials(config['exchange'], True)
 
         self.strategy: IStrategy = StrategyResolver.load_strategy(self.config)
 
@@ -70,7 +74,7 @@ class FreqtradeBot(LoggingMixin):
         validate_config_consistency(config)
 
         self.exchange = ExchangeResolver.load_exchange(
-            self.config['exchange']['name'], self.config, load_leverage_tiers=True)
+            self.config, exchange_config=exchange_config, load_leverage_tiers=True)
 
         init_db(self.config['db_url'])
 
@@ -420,7 +424,7 @@ class FreqtradeBot(LoggingMixin):
         """
         Try refinding a lost trade.
         Only used when InsufficientFunds appears on exit orders (stoploss or long sell/short buy).
-        Tries to walk the stored orders and sell them off eventually.
+        Tries to walk the stored orders and updates the trade state if necessary.
         """
         logger.info(f"Trying to refind lost order for {trade}")
         for order in trade.orders:
@@ -451,6 +455,42 @@ class FreqtradeBot(LoggingMixin):
             except ExchangeError:
                 logger.warning(f"Error updating {order.order_id}.")
 
+    def handle_onexchange_order(self, trade: Trade):
+        """
+        Try refinding a order that is not in the database.
+        Only used balance disappeared, which would make exiting impossible.
+        """
+        try:
+            orders = self.exchange.fetch_orders(trade.pair, trade.open_date_utc)
+            for order in orders:
+                trade_order = [o for o in trade.orders if o.order_id == order['id']]
+                if trade_order:
+                    continue
+                logger.info(f"Found previously unknown order {order['id']} for {trade.pair}.")
+
+                order_obj = Order.parse_from_ccxt_object(order, trade.pair, order['side'])
+                order_obj.order_filled_date = datetime.fromtimestamp(
+                    safe_value_fallback(order, 'lastTradeTimestamp', 'timestamp') // 1000,
+                    tz=timezone.utc)
+                trade.orders.append(order_obj)
+                # TODO: how do we handle open_order_id ...
+                Trade.commit()
+                prev_exit_reason = trade.exit_reason
+                trade.exit_reason = ExitType.SOLD_ON_EXCHANGE.value
+                self.update_trade_state(trade, order['id'], order)
+
+                logger.info(f"handled order {order['id']}")
+                if not trade.is_open:
+                    # Trade was just closed
+                    trade.close_date = order_obj.order_filled_date
+                    Trade.commit()
+                    break
+                else:
+                    trade.exit_reason = prev_exit_reason
+                    Trade.commit()
+
+        except ExchangeError:
+            logger.warning("Error finding onexchange order")
 #
 # BUY / enter positions / open trades logic and methods
 #
@@ -461,7 +501,7 @@ class FreqtradeBot(LoggingMixin):
         """
         trades_created = 0
 
-        whitelist = copy.deepcopy(self.active_pair_whitelist)
+        whitelist = deepcopy(self.active_pair_whitelist)
         if not whitelist:
             self.log_once("Active pair whitelist is empty.", logger.info)
             return trades_created
@@ -490,7 +530,8 @@ class FreqtradeBot(LoggingMixin):
         # Create entity and execute trade for each pair from whitelist
         for pair in whitelist:
             try:
-                trades_created += self.create_trade(pair)
+                with self._exit_lock:
+                    trades_created += self.create_trade(pair)
             except DependencyException as exception:
                 logger.warning('Unable to create trade for %s: %s', pair, exception)
 
@@ -981,7 +1022,7 @@ class FreqtradeBot(LoggingMixin):
             'base_currency': self.exchange.get_pair_base_currency(trade.pair),
             'fiat_currency': self.config.get('fiat_display_currency', None),
             'amount': order.safe_amount_after_fee if fill else (order.amount or trade.amount),
-            'open_date': trade.open_date or datetime.utcnow(),
+            'open_date': trade.open_date_utc or datetime.now(timezone.utc),
             'current_rate': current_rate,
             'sub_trade': sub_trade,
         }
@@ -1033,6 +1074,13 @@ class FreqtradeBot(LoggingMixin):
         """
         trades_closed = 0
         for trade in trades:
+
+            if trade.open_order_id is None and not self.wallets.check_exit_amount(trade):
+                logger.warning(
+                    f'Not enough {trade.safe_base_currency} in wallet to exit {trade}. '
+                    'Trying to recover.')
+                self.handle_onexchange_order(trade)
+
             try:
                 try:
                     if (self.strategy.order_types.get('stoploss_on_exchange') and
@@ -1535,13 +1583,13 @@ class FreqtradeBot(LoggingMixin):
         # Update wallets to ensure amounts tied up in a stoploss is now free!
         self.wallets.update()
         if self.trading_mode == TradingMode.FUTURES:
+            # A safe exit amount isn't needed for futures, you can just exit/close the position
             return amount
 
         trade_base_currency = self.exchange.get_pair_base_currency(pair)
         wallet_amount = self.wallets.get_free(trade_base_currency)
         logger.debug(f"{pair} - Wallet: {wallet_amount} - Trade-amount: {amount}")
         if wallet_amount >= amount:
-            # A safe exit amount isn't needed for futures, you can just exit/close the position
             return amount
         elif wallet_amount > amount * 0.98:
             logger.info(f"{pair} - Falling back to wallet-amount {wallet_amount} -> {amount}.")
@@ -1697,8 +1745,8 @@ class FreqtradeBot(LoggingMixin):
             'enter_tag': trade.enter_tag,
             'sell_reason': trade.exit_reason,  # Deprecated
             'exit_reason': trade.exit_reason,
-            'open_date': trade.open_date,
-            'close_date': trade.close_date or datetime.utcnow(),
+            'open_date': trade.open_date_utc,
+            'close_date': trade.close_date_utc or datetime.now(timezone.utc),
             'stake_amount': trade.stake_amount,
             'stake_currency': self.config['stake_currency'],
             'base_currency': self.exchange.get_pair_base_currency(trade.pair),
@@ -1720,10 +1768,8 @@ class FreqtradeBot(LoggingMixin):
         else:
             trade.exit_order_status = reason
 
-        order = trade.select_order_by_order_id(order_id)
-        if not order:
-            raise DependencyException(
-                f"Order_obj not found for {order_id}. This should not have happened.")
+        order_or_none = trade.select_order_by_order_id(order_id)
+        order = self.order_obj_or_raise(order_id, order_or_none)
 
         profit_rate: float = trade.safe_close_rate
         profit_trade = trade.calc_profit(rate=profit_rate)
@@ -1764,6 +1810,12 @@ class FreqtradeBot(LoggingMixin):
         # Send the message
         self.rpc.send_msg(msg)
 
+    def order_obj_or_raise(self, order_id: str, order_obj: Optional[Order]) -> Order:
+        if not order_obj:
+            raise DependencyException(
+                f"Order_obj not found for {order_id}. This should not have happened.")
+        return order_obj
+
 #
 # Common update trade state methods
 #
@@ -1802,10 +1854,8 @@ class FreqtradeBot(LoggingMixin):
             # Handling of this will happen in check_handle_timedout.
             return True
 
-        order_obj = trade.select_order_by_order_id(order_id)
-        if not order_obj:
-            raise DependencyException(
-                f"Order_obj not found for {order_id}. This should not have happened.")
+        order_obj_or_none = trade.select_order_by_order_id(order_id)
+        order_obj = self.order_obj_or_raise(order_id, order_obj_or_none)
 
         self.handle_order_fee(trade, order_obj, order)
 
@@ -1823,16 +1873,18 @@ class FreqtradeBot(LoggingMixin):
                 # Must also run for partial exits
                 # TODO: Margin will need to use interest_rate as well.
                 # interest_rate = self.exchange.get_interest_rate()
-                trade.set_liquidation_price(self.exchange.get_liquidation_price(
-                    pair=trade.pair,
-                    open_rate=trade.open_rate,
-                    is_short=trade.is_short,
-                    amount=trade.amount,
-                    stake_amount=trade.stake_amount,
-                    leverage=trade.leverage,
-                    wallet_balance=trade.stake_amount,
-                ))
-
+                try:
+                    trade.set_liquidation_price(self.exchange.get_liquidation_price(
+                        pair=trade.pair,
+                        open_rate=trade.open_rate,
+                        is_short=trade.is_short,
+                        amount=trade.amount,
+                        stake_amount=trade.stake_amount,
+                        leverage=trade.leverage,
+                        wallet_balance=trade.stake_amount,
+                    ))
+                except DependencyException:
+                    logger.warning('Unable to calculate liquidation price')
             # Updating wallets when order is closed
             self.wallets.update()
         Trade.commit()
diff --git a/freqtrade/loggers/__init__.py b/freqtrade/loggers/__init__.py
index 528d274f2..58f207608 100644
--- a/freqtrade/loggers/__init__.py
+++ b/freqtrade/loggers/__init__.py
@@ -32,6 +32,7 @@ def _set_loggers(verbosity: int = 0, api_verbosity: str = 'info') -> None:
         logging.INFO if verbosity <= 2 else logging.DEBUG
     )
     logging.getLogger('telegram').setLevel(logging.INFO)
+    logging.getLogger('httpx').setLevel(logging.INFO)
 
     logging.getLogger('werkzeug').setLevel(
         logging.ERROR if api_verbosity == 'error' else logging.INFO
diff --git a/freqtrade/misc.py b/freqtrade/misc.py
index 0cd5c6ffd..1e84bba87 100644
--- a/freqtrade/misc.py
+++ b/freqtrade/misc.py
@@ -3,13 +3,11 @@ Various tool function for Freqtrade and scripts
 """
 import gzip
 import logging
-import re
 from datetime import datetime
 from pathlib import Path
 from typing import Any, Dict, Iterator, List, Mapping, Optional, TextIO, Union
 from urllib.parse import urlparse
 
-import orjson
 import pandas as pd
 import rapidjson
 
@@ -48,18 +46,6 @@ def round_coin_value(
     return val
 
 
-def shorten_date(_date: str) -> str:
-    """
-    Trim the date so it fits on small screens
-    """
-    new_date = re.sub('seconds?', 'sec', _date)
-    new_date = re.sub('minutes?', 'min', new_date)
-    new_date = re.sub('hours?', 'h', new_date)
-    new_date = re.sub('days?', 'd', new_date)
-    new_date = re.sub('^an?', '1', new_date)
-    return new_date
-
-
 def file_dump_json(filename: Path, data: Any, is_zip: bool = False, log: bool = True) -> None:
     """
     Dump JSON data into a file
@@ -262,17 +248,7 @@ def dataframe_to_json(dataframe: pd.DataFrame) -> str:
     :param dataframe: A pandas DataFrame
     :returns: A JSON string of the pandas DataFrame
     """
-    # https://github.com/pandas-dev/pandas/issues/24889
-    # https://github.com/pandas-dev/pandas/issues/40443
-    # We need to convert to a dict to avoid mem leak
-    def default(z):
-        if isinstance(z, pd.Timestamp):
-            return z.timestamp() * 1e3
-        if z is pd.NaT:
-            return 'NaT'
-        raise TypeError
-
-    return str(orjson.dumps(dataframe.to_dict(orient='split'), default=default), 'utf-8')
+    return dataframe.to_json(orient='split')
 
 
 def json_to_dataframe(data: str) -> pd.DataFrame:
diff --git a/freqtrade/optimize/backtesting.py b/freqtrade/optimize/backtesting.py
index c7b2a0d3c..d77fc469b 100644
--- a/freqtrade/optimize/backtesting.py
+++ b/freqtrade/optimize/backtesting.py
@@ -9,7 +9,6 @@ from copy import deepcopy
 from datetime import datetime, timedelta, timezone
 from typing import Any, Dict, List, Optional, Tuple
 
-import pandas as pd
 from numpy import nan
 from pandas import DataFrame
 
@@ -28,8 +27,10 @@ from freqtrade.exchange import (amount_to_contract_precision, price_to_precision
 from freqtrade.mixins import LoggingMixin
 from freqtrade.optimize.backtest_caching import get_strategy_run_id
 from freqtrade.optimize.bt_progress import BTProgress
-from freqtrade.optimize.optimize_reports import (generate_backtest_stats, show_backtest_results,
-                                                 store_backtest_signal_candles,
+from freqtrade.optimize.optimize_reports import (generate_backtest_stats, generate_rejected_signals,
+                                                 generate_trade_signal_candles,
+                                                 show_backtest_results,
+                                                 store_backtest_analysis_results,
                                                  store_backtest_stats)
 from freqtrade.persistence import LocalTrade, Order, PairLocks, Trade
 from freqtrade.plugins.pairlistmanager import PairListManager
@@ -84,10 +85,11 @@ class Backtesting:
         self.strategylist: List[IStrategy] = []
         self.all_results: Dict[str, Dict] = {}
         self.processed_dfs: Dict[str, Dict] = {}
+        self.rejected_dict: Dict[str, List] = {}
+        self.rejected_df: Dict[str, Dict] = {}
 
         self._exchange_name = self.config['exchange']['name']
-        self.exchange = ExchangeResolver.load_exchange(
-            self._exchange_name, self.config, load_leverage_tiers=True)
+        self.exchange = ExchangeResolver.load_exchange(self.config, load_leverage_tiers=True)
         self.dataprovider = DataProvider(self.config, self.exchange)
 
         if self.config.get('strategy_list'):
@@ -1056,6 +1058,18 @@ class Backtesting:
             return None
         return row
 
+    def _collate_rejected(self, pair, row):
+        """
+        Temporarily store rejected signal information for downstream use in backtesting_analysis
+        """
+        # It could be fun to enable hyperopt mode to write
+        # a loss function to reduce rejected signals
+        if (self.config.get('export', 'none') == 'signals' and
+                self.dataprovider.runmode == RunMode.BACKTEST):
+            if pair not in self.rejected_dict:
+                self.rejected_dict[pair] = []
+            self.rejected_dict[pair].append([row[DATE_IDX], row[ENTER_TAG_IDX]])
+
     def backtest_loop(
             self, row: Tuple, pair: str, current_time: datetime, end_date: datetime,
             open_trade_count_start: int, trade_dir: Optional[LongShort],
@@ -1081,20 +1095,22 @@ class Backtesting:
         if (
             (self._position_stacking or len(LocalTrade.bt_trades_open_pp[pair]) == 0)
             and is_first
-            and self.trade_slot_available(open_trade_count_start)
             and current_time != end_date
             and trade_dir is not None
             and not PairLocks.is_pair_locked(pair, row[DATE_IDX], trade_dir)
         ):
-            trade = self._enter_trade(pair, row, trade_dir)
-            if trade:
-                # TODO: hacky workaround to avoid opening > max_open_trades
-                # This emulates previous behavior - not sure if this is correct
-                # Prevents entering if the trade-slot was freed in this candle
-                open_trade_count_start += 1
-                # logger.debug(f"{pair} - Emulate creation of new trade: {trade}.")
-                LocalTrade.add_bt_trade(trade)
-                self.wallets.update()
+            if (self.trade_slot_available(open_trade_count_start)):
+                trade = self._enter_trade(pair, row, trade_dir)
+                if trade:
+                    # TODO: hacky workaround to avoid opening > max_open_trades
+                    # This emulates previous behavior - not sure if this is correct
+                    # Prevents entering if the trade-slot was freed in this candle
+                    open_trade_count_start += 1
+                    # logger.debug(f"{pair} - Emulate creation of new trade: {trade}.")
+                    LocalTrade.add_bt_trade(trade)
+                    self.wallets.update()
+            else:
+                self._collate_rejected(pair, row)
 
         for trade in list(LocalTrade.bt_trades_open_pp[pair]):
             # 3. Process entry orders.
@@ -1236,8 +1252,8 @@ class Backtesting:
     def backtest_one_strategy(self, strat: IStrategy, data: Dict[str, DataFrame],
                               timerange: TimeRange):
         self.progress.init_step(BacktestState.ANALYZE, 0)
-
-        logger.info(f"Running backtesting for Strategy {strat.get_strategy_name()}")
+        strategy_name = strat.get_strategy_name()
+        logger.info(f"Running backtesting for Strategy {strategy_name}")
         backtest_start_time = datetime.now(timezone.utc)
         self._set_strategy(strat)
 
@@ -1272,37 +1288,21 @@ class Backtesting:
         )
         backtest_end_time = datetime.now(timezone.utc)
         results.update({
-            'run_id': self.run_ids.get(strat.get_strategy_name(), ''),
+            'run_id': self.run_ids.get(strategy_name, ''),
             'backtest_start_time': int(backtest_start_time.timestamp()),
             'backtest_end_time': int(backtest_end_time.timestamp()),
         })
-        self.all_results[self.strategy.get_strategy_name()] = results
+        self.all_results[strategy_name] = results
 
         if (self.config.get('export', 'none') == 'signals' and
                 self.dataprovider.runmode == RunMode.BACKTEST):
-            self._generate_trade_signal_candles(preprocessed_tmp, results)
+            self.processed_dfs[strategy_name] = generate_trade_signal_candles(
+                preprocessed_tmp, results)
+            self.rejected_df[strategy_name] = generate_rejected_signals(
+                preprocessed_tmp, self.rejected_dict)
 
         return min_date, max_date
 
-    def _generate_trade_signal_candles(self, preprocessed_df, bt_results):
-        signal_candles_only = {}
-        for pair in preprocessed_df.keys():
-            signal_candles_only_df = DataFrame()
-
-            pairdf = preprocessed_df[pair]
-            resdf = bt_results['results']
-            pairresults = resdf.loc[(resdf["pair"] == pair)]
-
-            if pairdf.shape[0] > 0:
-                for t, v in pairresults.open_date.items():
-                    allinds = pairdf.loc[(pairdf['date'] < v)]
-                    signal_inds = allinds.iloc[[-1]]
-                    signal_candles_only_df = pd.concat([signal_candles_only_df, signal_inds])
-
-                signal_candles_only[pair] = signal_candles_only_df
-
-        self.processed_dfs[self.strategy.get_strategy_name()] = signal_candles_only
-
     def _get_min_cached_backtest_date(self):
         min_backtest_date = None
         backtest_cache_age = self.config.get('backtest_cache', constants.BACKTEST_CACHE_DEFAULT)
@@ -1365,8 +1365,9 @@ class Backtesting:
 
             if (self.config.get('export', 'none') == 'signals' and
                     self.dataprovider.runmode == RunMode.BACKTEST):
-                store_backtest_signal_candles(
-                    self.config['exportfilename'], self.processed_dfs, dt_appendix)
+                store_backtest_analysis_results(
+                    self.config['exportfilename'], self.processed_dfs, self.rejected_df,
+                    dt_appendix)
 
         # Results may be mixed up now. Sort them so they follow --strategy-list order.
         if 'strategy_list' in self.config and len(self.results) > 0:
diff --git a/freqtrade/optimize/edge_cli.py b/freqtrade/optimize/edge_cli.py
index 2eb1c53f5..07c54d720 100644
--- a/freqtrade/optimize/edge_cli.py
+++ b/freqtrade/optimize/edge_cli.py
@@ -32,7 +32,7 @@ class EdgeCli:
         # Ensure using dry-run
         self.config['dry_run'] = True
         self.config['stake_amount'] = constants.UNLIMITED_STAKE_AMOUNT
-        self.exchange = ExchangeResolver.load_exchange(self.config['exchange']['name'], self.config)
+        self.exchange = ExchangeResolver.load_exchange(self.config)
         self.strategy = StrategyResolver.load_strategy(self.config)
         self.strategy.dp = DataProvider(config, self.exchange)
 
diff --git a/freqtrade/optimize/optimize_reports.py b/freqtrade/optimize/optimize_reports.py
index 1c5088cc1..e60047a79 100644
--- a/freqtrade/optimize/optimize_reports.py
+++ b/freqtrade/optimize/optimize_reports.py
@@ -4,7 +4,7 @@ from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Any, Dict, List, Union
 
-from pandas import DataFrame, to_datetime
+from pandas import DataFrame, concat, to_datetime
 from tabulate import tabulate
 
 from freqtrade.constants import (BACKTEST_BREAKDOWNS, DATETIME_PRINT_FORMAT, LAST_BT_RESULT_FN,
@@ -46,29 +46,80 @@ def store_backtest_stats(
     file_dump_json(latest_filename, {'latest_backtest': str(filename.name)})
 
 
-def store_backtest_signal_candles(
-        recordfilename: Path, candles: Dict[str, Dict], dtappendix: str) -> Path:
+def _store_backtest_analysis_data(
+        recordfilename: Path, data: Dict[str, Dict],
+        dtappendix: str, name: str) -> Path:
     """
-    Stores backtest trade signal candles
+    Stores backtest trade candles for analysis
     :param recordfilename: Path object, which can either be a filename or a directory.
         Filenames will be appended with a timestamp right before the suffix
-        while for directories, <directory>/backtest-result-<datetime>_signals.pkl will be used
+        while for directories, <directory>/backtest-result-<datetime>_<name>.pkl will be used
         as filename
-    :param stats: Dict containing the backtesting signal candles
+    :param candles: Dict containing the backtesting data for analysis
     :param dtappendix: Datetime to use for the filename
+    :param name: Name to use for the file, e.g. signals, rejected
     """
     if recordfilename.is_dir():
-        filename = (recordfilename / f'backtest-result-{dtappendix}_signals.pkl')
+        filename = (recordfilename / f'backtest-result-{dtappendix}_{name}.pkl')
     else:
         filename = Path.joinpath(
-            recordfilename.parent, f'{recordfilename.stem}-{dtappendix}_signals.pkl'
+            recordfilename.parent, f'{recordfilename.stem}-{dtappendix}_{name}.pkl'
         )
 
-    file_dump_joblib(filename, candles)
+    file_dump_joblib(filename, data)
 
     return filename
 
 
+def store_backtest_analysis_results(
+        recordfilename: Path, candles: Dict[str, Dict], trades: Dict[str, Dict],
+        dtappendix: str) -> None:
+    _store_backtest_analysis_data(recordfilename, candles, dtappendix, "signals")
+    _store_backtest_analysis_data(recordfilename, trades, dtappendix, "rejected")
+
+
+def generate_trade_signal_candles(preprocessed_df: Dict[str, DataFrame],
+                                  bt_results: Dict[str, Any]) -> DataFrame:
+    signal_candles_only = {}
+    for pair in preprocessed_df.keys():
+        signal_candles_only_df = DataFrame()
+
+        pairdf = preprocessed_df[pair]
+        resdf = bt_results['results']
+        pairresults = resdf.loc[(resdf["pair"] == pair)]
+
+        if pairdf.shape[0] > 0:
+            for t, v in pairresults.open_date.items():
+                allinds = pairdf.loc[(pairdf['date'] < v)]
+                signal_inds = allinds.iloc[[-1]]
+                signal_candles_only_df = concat([
+                    signal_candles_only_df.infer_objects(),
+                    signal_inds.infer_objects()])
+
+            signal_candles_only[pair] = signal_candles_only_df
+    return signal_candles_only
+
+
+def generate_rejected_signals(preprocessed_df: Dict[str, DataFrame],
+                              rejected_dict: Dict[str, DataFrame]) -> Dict[str, DataFrame]:
+    rejected_candles_only = {}
+    for pair, signals in rejected_dict.items():
+        rejected_signals_only_df = DataFrame()
+        pairdf = preprocessed_df[pair]
+
+        for t in signals:
+            data_df_row = pairdf.loc[(pairdf['date'] == t[0])].copy()
+            data_df_row['pair'] = pair
+            data_df_row['enter_tag'] = t[1]
+
+            rejected_signals_only_df = concat([
+                rejected_signals_only_df.infer_objects(),
+                data_df_row.infer_objects()])
+
+        rejected_candles_only[pair] = rejected_signals_only_df
+    return rejected_candles_only
+
+
 def _get_line_floatfmt(stake_currency: str) -> List[str]:
     """
     Generate floatformat (goes in line with _generate_result_line())
diff --git a/freqtrade/persistence/key_value_store.py b/freqtrade/persistence/key_value_store.py
index 2d26acbd3..110a23d6c 100644
--- a/freqtrade/persistence/key_value_store.py
+++ b/freqtrade/persistence/key_value_store.py
@@ -36,7 +36,7 @@ class _KeyValueStoreModel(ModelBase):
 
     value_type: Mapped[ValueTypesEnum] = mapped_column(String(20), nullable=False)
 
-    string_value: Mapped[Optional[str]]
+    string_value: Mapped[Optional[str]] = mapped_column(String(255), nullable=True)
     datetime_value: Mapped[Optional[datetime]]
     float_value: Mapped[Optional[float]]
     int_value: Mapped[Optional[int]]
diff --git a/freqtrade/persistence/trade_model.py b/freqtrade/persistence/trade_model.py
index 0572b45a6..5d8aada6b 100644
--- a/freqtrade/persistence/trade_model.py
+++ b/freqtrade/persistence/trade_model.py
@@ -19,7 +19,7 @@ from freqtrade.exchange import (ROUND_DOWN, ROUND_UP, amount_to_contract_precisi
                                 price_to_precision)
 from freqtrade.leverage import interest
 from freqtrade.persistence.base import ModelBase, SessionType
-from freqtrade.util import FtPrecise
+from freqtrade.util import FtPrecise, dt_now
 
 
 logger = logging.getLogger(__name__)
@@ -68,7 +68,7 @@ class Order(ModelBase):
     remaining: Mapped[Optional[float]] = mapped_column(Float(), nullable=True)
     cost: Mapped[Optional[float]] = mapped_column(Float(), nullable=True)
     stop_price: Mapped[Optional[float]] = mapped_column(Float(), nullable=True)
-    order_date: Mapped[datetime] = mapped_column(nullable=True, default=datetime.utcnow)
+    order_date: Mapped[datetime] = mapped_column(nullable=True, default=dt_now)
     order_filled_date: Mapped[Optional[datetime]] = mapped_column(nullable=True)
     order_update_date: Mapped[Optional[datetime]] = mapped_column(nullable=True)
     funding_fee: Mapped[Optional[float]] = mapped_column(Float(), nullable=True)
@@ -158,7 +158,7 @@ class Order(ModelBase):
                 self.order_filled_date = datetime.now(timezone.utc)
         self.order_update_date = datetime.now(timezone.utc)
 
-    def to_ccxt_object(self) -> Dict[str, Any]:
+    def to_ccxt_object(self, stopPriceName: str = 'stopPrice') -> Dict[str, Any]:
         order: Dict[str, Any] = {
             'id': self.order_id,
             'symbol': self.ft_pair,
@@ -170,7 +170,6 @@ class Order(ModelBase):
             'side': self.ft_order_side,
             'filled': self.filled,
             'remaining': self.remaining,
-            'stopPrice': self.stop_price,
             'datetime': self.order_date_utc.strftime('%Y-%m-%dT%H:%M:%S.%f'),
             'timestamp': int(self.order_date_utc.timestamp() * 1000),
             'status': self.status,
@@ -178,7 +177,11 @@ class Order(ModelBase):
             'info': {},
         }
         if self.ft_order_side == 'stoploss':
-            order['ft_order_type'] = 'stoploss'
+            order.update({
+                stopPriceName: self.stop_price,
+                'ft_order_type': 'stoploss',
+            })
+
         return order
 
     def to_json(self, entry_side: str, minified: bool = False) -> Dict[str, Any]:
@@ -422,7 +425,7 @@ class LocalTrade():
 
     @property
     def close_date_utc(self):
-        return self.close_date.replace(tzinfo=timezone.utc)
+        return self.close_date.replace(tzinfo=timezone.utc) if self.close_date else None
 
     @property
     def entry_side(self) -> str:
@@ -708,7 +711,10 @@ class LocalTrade():
         if order.ft_order_side != self.entry_side:
             amount_tr = amount_to_contract_precision(self.amount, self.amount_precision,
                                                      self.precision_mode, self.contract_size)
-            if isclose(order.safe_amount_after_fee, amount_tr, abs_tol=MATH_CLOSE_PREC):
+            if (
+                isclose(order.safe_amount_after_fee, amount_tr, abs_tol=MATH_CLOSE_PREC)
+                or order.safe_amount_after_fee > amount_tr
+            ):
                 self.close(order.safe_price)
             else:
                 self.recalc_trade_from_orders()
diff --git a/freqtrade/plot/plotting.py b/freqtrade/plot/plotting.py
index e415c4911..7fd20f041 100644
--- a/freqtrade/plot/plotting.py
+++ b/freqtrade/plot/plotting.py
@@ -633,7 +633,7 @@ def load_and_plot_trades(config: Config):
     """
     strategy = StrategyResolver.load_strategy(config)
 
-    exchange = ExchangeResolver.load_exchange(config['exchange']['name'], config)
+    exchange = ExchangeResolver.load_exchange(config)
     IStrategy.dp = DataProvider(config, exchange)
     strategy.ft_bot_start()
     strategy.bot_loop_start(datetime.now(timezone.utc))
@@ -678,7 +678,7 @@ def plot_profit(config: Config) -> None:
     if 'timeframe' not in config:
         raise OperationalException('Timeframe must be set in either config or via --timeframe.')
 
-    exchange = ExchangeResolver.load_exchange(config['exchange']['name'], config)
+    exchange = ExchangeResolver.load_exchange(config)
     plot_elements = init_plotscript(config, list(exchange.markets))
     trades = plot_elements['trades']
     # Filter trades to relevant pairs
diff --git a/freqtrade/plugins/pairlist/AgeFilter.py b/freqtrade/plugins/pairlist/AgeFilter.py
index f9c02e250..2af86592f 100644
--- a/freqtrade/plugins/pairlist/AgeFilter.py
+++ b/freqtrade/plugins/pairlist/AgeFilter.py
@@ -3,9 +3,9 @@ Minimum age (days listed) pair list filter
 """
 import logging
 from copy import deepcopy
+from datetime import timedelta
 from typing import Any, Dict, List, Optional
 
-import arrow
 from pandas import DataFrame
 
 from freqtrade.constants import Config, ListPairsWithTimeframes
@@ -13,7 +13,7 @@ from freqtrade.exceptions import OperationalException
 from freqtrade.exchange.types import Tickers
 from freqtrade.misc import plural
 from freqtrade.plugins.pairlist.IPairList import IPairList
-from freqtrade.util import PeriodicCache
+from freqtrade.util import PeriodicCache, dt_floor_day, dt_now, dt_ts
 
 
 logger = logging.getLogger(__name__)
@@ -84,10 +84,7 @@ class AgeFilter(IPairList):
         since_days = -(
             self._max_days_listed if self._max_days_listed else self._min_days_listed
         ) - 1
-        since_ms = int(arrow.utcnow()
-                       .floor('day')
-                       .shift(days=since_days)
-                       .float_timestamp) * 1000
+        since_ms = dt_ts(dt_floor_day(dt_now()) + timedelta(days=since_days))
         candles = self._exchange.refresh_latest_ohlcv(needed_pairs, since_ms=since_ms, cache=False)
         if self._enabled:
             for p in deepcopy(pairlist):
@@ -116,7 +113,7 @@ class AgeFilter(IPairList):
             ):
                 # We have fetched at least the minimum required number of daily candles
                 # Add to cache, store the time we last checked this symbol
-                self._symbolsChecked[pair] = arrow.utcnow().int_timestamp * 1000
+                self._symbolsChecked[pair] = dt_ts()
                 return True
             else:
                 self.log_once((
@@ -127,6 +124,6 @@ class AgeFilter(IPairList):
                     " or more than "
                     f"{self._max_days_listed} {plural(self._max_days_listed, 'day')}"
                 ) if self._max_days_listed else ''), logger.info)
-                self._symbolsCheckFailed[pair] = arrow.utcnow().int_timestamp * 1000
+                self._symbolsCheckFailed[pair] = dt_ts()
                 return False
         return False
diff --git a/freqtrade/plugins/pairlist/VolatilityFilter.py b/freqtrade/plugins/pairlist/VolatilityFilter.py
index 401a2e86c..61a1dcbf0 100644
--- a/freqtrade/plugins/pairlist/VolatilityFilter.py
+++ b/freqtrade/plugins/pairlist/VolatilityFilter.py
@@ -4,9 +4,9 @@ Volatility pairlist filter
 import logging
 import sys
 from copy import deepcopy
+from datetime import timedelta
 from typing import Any, Dict, List, Optional
 
-import arrow
 import numpy as np
 from cachetools import TTLCache
 from pandas import DataFrame
@@ -16,6 +16,7 @@ from freqtrade.exceptions import OperationalException
 from freqtrade.exchange.types import Tickers
 from freqtrade.misc import plural
 from freqtrade.plugins.pairlist.IPairList import IPairList
+from freqtrade.util import dt_floor_day, dt_now, dt_ts
 
 
 logger = logging.getLogger(__name__)
@@ -73,10 +74,7 @@ class VolatilityFilter(IPairList):
         needed_pairs: ListPairsWithTimeframes = [
             (p, '1d', self._def_candletype) for p in pairlist if p not in self._pair_cache]
 
-        since_ms = (arrow.utcnow()
-                         .floor('day')
-                         .shift(days=-self._days - 1)
-                         .int_timestamp) * 1000
+        since_ms = dt_ts(dt_floor_day(dt_now()) - timedelta(days=self._days))
         # Get all candles
         candles = {}
         if needed_pairs:
@@ -105,7 +103,7 @@ class VolatilityFilter(IPairList):
 
         result = False
         if daily_candles is not None and not daily_candles.empty:
-            returns = (np.log(daily_candles.close / daily_candles.close.shift(-1)))
+            returns = (np.log(daily_candles["close"].shift(1) / daily_candles["close"]))
             returns.fillna(0, inplace=True)
 
             volatility_series = returns.rolling(window=self._days).std() * np.sqrt(self._days)
diff --git a/freqtrade/plugins/pairlist/VolumePairList.py b/freqtrade/plugins/pairlist/VolumePairList.py
index 2649a8425..b9c312f87 100644
--- a/freqtrade/plugins/pairlist/VolumePairList.py
+++ b/freqtrade/plugins/pairlist/VolumePairList.py
@@ -4,7 +4,7 @@ Volume PairList provider
 Provides dynamic pair list based on trade volumes
 """
 import logging
-from datetime import datetime, timedelta, timezone
+from datetime import timedelta
 from typing import Any, Dict, List, Literal
 
 from cachetools import TTLCache
@@ -15,6 +15,7 @@ from freqtrade.exchange import timeframe_to_minutes, timeframe_to_prev_date
 from freqtrade.exchange.types import Tickers
 from freqtrade.misc import format_ms_time
 from freqtrade.plugins.pairlist.IPairList import IPairList
+from freqtrade.util import dt_now
 
 
 logger = logging.getLogger(__name__)
@@ -161,13 +162,13 @@ class VolumePairList(IPairList):
             # get lookback period in ms, for exchange ohlcv fetch
             since_ms = int(timeframe_to_prev_date(
                 self._lookback_timeframe,
-                datetime.now(timezone.utc) + timedelta(
+                dt_now() + timedelta(
                     minutes=-(self._lookback_period * self._tf_in_min) - self._tf_in_min)
                     ).timestamp()) * 1000
 
             to_ms = int(timeframe_to_prev_date(
                             self._lookback_timeframe,
-                            datetime.now(timezone.utc) - timedelta(minutes=self._tf_in_min)
+                            dt_now() - timedelta(minutes=self._tf_in_min)
                             ).timestamp()) * 1000
 
             # todo: utc date output for starting date
diff --git a/freqtrade/plugins/pairlist/rangestabilityfilter.py b/freqtrade/plugins/pairlist/rangestabilityfilter.py
index 546b026cb..1181b2812 100644
--- a/freqtrade/plugins/pairlist/rangestabilityfilter.py
+++ b/freqtrade/plugins/pairlist/rangestabilityfilter.py
@@ -3,9 +3,9 @@ Rate of change pairlist filter
 """
 import logging
 from copy import deepcopy
+from datetime import timedelta
 from typing import Any, Dict, List, Optional
 
-import arrow
 from cachetools import TTLCache
 from pandas import DataFrame
 
@@ -14,6 +14,7 @@ from freqtrade.exceptions import OperationalException
 from freqtrade.exchange.types import Tickers
 from freqtrade.misc import plural
 from freqtrade.plugins.pairlist.IPairList import IPairList
+from freqtrade.util import dt_floor_day, dt_now, dt_ts
 
 
 logger = logging.getLogger(__name__)
@@ -71,10 +72,7 @@ class RangeStabilityFilter(IPairList):
         needed_pairs: ListPairsWithTimeframes = [
             (p, '1d', self._def_candletype) for p in pairlist if p not in self._pair_cache]
 
-        since_ms = (arrow.utcnow()
-                         .floor('day')
-                         .shift(days=-self._days - 1)
-                         .int_timestamp) * 1000
+        since_ms = dt_ts(dt_floor_day(dt_now()) - timedelta(days=self._days - 1))
         # Get all candles
         candles = {}
         if needed_pairs:
diff --git a/freqtrade/resolvers/exchange_resolver.py b/freqtrade/resolvers/exchange_resolver.py
index 54a488e8d..c5c4e1a68 100644
--- a/freqtrade/resolvers/exchange_resolver.py
+++ b/freqtrade/resolvers/exchange_resolver.py
@@ -2,9 +2,10 @@
 This module loads custom exchanges
 """
 import logging
+from typing import Optional
 
 import freqtrade.exchange as exchanges
-from freqtrade.constants import Config
+from freqtrade.constants import Config, ExchangeConfig
 from freqtrade.exchange import MAP_EXCHANGE_CHILDCLASS, Exchange
 from freqtrade.resolvers import IResolver
 
@@ -19,13 +20,14 @@ class ExchangeResolver(IResolver):
     object_type = Exchange
 
     @staticmethod
-    def load_exchange(exchange_name: str, config: Config, validate: bool = True,
-                      load_leverage_tiers: bool = False) -> Exchange:
+    def load_exchange(config: Config, *, exchange_config: Optional[ExchangeConfig] = None,
+                      validate: bool = True, load_leverage_tiers: bool = False) -> Exchange:
         """
         Load the custom class from config parameter
         :param exchange_name: name of the Exchange to load
         :param config: configuration dictionary
         """
+        exchange_name: str = config['exchange']['name']
         # Map exchange name to avoid duplicate classes for identical exchanges
         exchange_name = MAP_EXCHANGE_CHILDCLASS.get(exchange_name, exchange_name)
         exchange_name = exchange_name.title()
@@ -36,13 +38,14 @@ class ExchangeResolver(IResolver):
                 kwargs={
                     'config': config,
                     'validate': validate,
+                    'exchange_config': exchange_config,
                     'load_leverage_tiers': load_leverage_tiers}
             )
         except ImportError:
             logger.info(
                 f"No {exchange_name} specific subclass found. Using the generic class instead.")
         if not exchange:
-            exchange = Exchange(config, validate=validate)
+            exchange = Exchange(config, validate=validate, exchange_config=exchange_config,)
         return exchange
 
     @staticmethod
diff --git a/freqtrade/rpc/api_server/api_backtest.py b/freqtrade/rpc/api_server/api_backtest.py
index d9d7a27f1..8fa1a87b8 100644
--- a/freqtrade/rpc/api_server/api_backtest.py
+++ b/freqtrade/rpc/api_server/api_backtest.py
@@ -8,14 +8,16 @@ from fastapi import APIRouter, BackgroundTasks, Depends
 from fastapi.exceptions import HTTPException
 
 from freqtrade.configuration.config_validation import validate_config_consistency
+from freqtrade.constants import Config
 from freqtrade.data.btanalysis import get_backtest_resultlist, load_and_merge_backtest_result
 from freqtrade.enums import BacktestState
 from freqtrade.exceptions import DependencyException, OperationalException
+from freqtrade.exchange.common import remove_exchange_credentials
 from freqtrade.misc import deep_merge_dicts
 from freqtrade.rpc.api_server.api_schemas import (BacktestHistoryEntry, BacktestRequest,
                                                   BacktestResponse)
 from freqtrade.rpc.api_server.deps import get_config, is_webserver_mode
-from freqtrade.rpc.api_server.webserver import ApiServer
+from freqtrade.rpc.api_server.webserver_bgwork import ApiBG
 from freqtrade.rpc.rpc import RPCException
 
 
@@ -25,19 +27,92 @@ logger = logging.getLogger(__name__)
 router = APIRouter()
 
 
+def __run_backtest_bg(btconfig: Config):
+    from freqtrade.optimize.optimize_reports import generate_backtest_stats, store_backtest_stats
+    from freqtrade.resolvers import StrategyResolver
+    asyncio.set_event_loop(asyncio.new_event_loop())
+    try:
+        # Reload strategy
+        lastconfig = ApiBG.bt['last_config']
+        strat = StrategyResolver.load_strategy(btconfig)
+        validate_config_consistency(btconfig)
+
+        if (
+            not ApiBG.bt['bt']
+            or lastconfig.get('timeframe') != strat.timeframe
+            or lastconfig.get('timeframe_detail') != btconfig.get('timeframe_detail')
+            or lastconfig.get('timerange') != btconfig['timerange']
+        ):
+            from freqtrade.optimize.backtesting import Backtesting
+            ApiBG.bt['bt'] = Backtesting(btconfig)
+            ApiBG.bt['bt'].load_bt_data_detail()
+        else:
+            ApiBG.bt['bt'].config = btconfig
+            ApiBG.bt['bt'].init_backtest()
+        # Only reload data if timeframe changed.
+        if (
+            not ApiBG.bt['data']
+            or not ApiBG.bt['timerange']
+            or lastconfig.get('timeframe') != strat.timeframe
+            or lastconfig.get('timerange') != btconfig['timerange']
+        ):
+            ApiBG.bt['data'], ApiBG.bt['timerange'] = ApiBG.bt[
+                'bt'].load_bt_data()
+
+        lastconfig['timerange'] = btconfig['timerange']
+        lastconfig['timeframe'] = strat.timeframe
+        lastconfig['protections'] = btconfig.get('protections', [])
+        lastconfig['enable_protections'] = btconfig.get('enable_protections')
+        lastconfig['dry_run_wallet'] = btconfig.get('dry_run_wallet')
+
+        ApiBG.bt['bt'].enable_protections = btconfig.get('enable_protections', False)
+        ApiBG.bt['bt'].strategylist = [strat]
+        ApiBG.bt['bt'].results = {}
+        ApiBG.bt['bt'].load_prior_backtest()
+
+        ApiBG.bt['bt'].abort = False
+        if (ApiBG.bt['bt'].results and
+                strat.get_strategy_name() in ApiBG.bt['bt'].results['strategy']):
+            # When previous result hash matches - reuse that result and skip backtesting.
+            logger.info(f'Reusing result of previous backtest for {strat.get_strategy_name()}')
+        else:
+            min_date, max_date = ApiBG.bt['bt'].backtest_one_strategy(
+                strat, ApiBG.bt['data'], ApiBG.bt['timerange'])
+
+            ApiBG.bt['bt'].results = generate_backtest_stats(
+                ApiBG.bt['data'], ApiBG.bt['bt'].all_results,
+                min_date=min_date, max_date=max_date)
+
+        if btconfig.get('export', 'none') == 'trades':
+            store_backtest_stats(
+                btconfig['exportfilename'], ApiBG.bt['bt'].results,
+                datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+                )
+
+        logger.info("Backtest finished.")
+
+    except (Exception, OperationalException, DependencyException) as e:
+        logger.exception(f"Backtesting caused an error: {e}")
+        ApiBG.bt['bt_error'] = str(e)
+        pass
+    finally:
+        ApiBG.bgtask_running = False
+
+
 @router.post('/backtest', response_model=BacktestResponse, tags=['webserver', 'backtest'])
-async def api_start_backtest(  # noqa: C901
+async def api_start_backtest(
         bt_settings: BacktestRequest, background_tasks: BackgroundTasks,
         config=Depends(get_config), ws_mode=Depends(is_webserver_mode)):
-    ApiServer._bt['bt_error'] = None
+    ApiBG.bt['bt_error'] = None
     """Start backtesting if not done so already"""
-    if ApiServer._bgtask_running:
+    if ApiBG.bgtask_running:
         raise RPCException('Bot Background task already running')
 
     if ':' in bt_settings.strategy:
         raise HTTPException(status_code=500, detail="base64 encoded strategies are not allowed.")
 
     btconfig = deepcopy(config)
+    remove_exchange_credentials(btconfig['exchange'], True)
     settings = dict(bt_settings)
     if settings.get('freqai', None) is not None:
         settings['freqai'] = dict(settings['freqai'])
@@ -54,80 +129,9 @@ async def api_start_backtest(  # noqa: C901
 
     # Start backtesting
     # Initialize backtesting object
-    def run_backtest():
-        from freqtrade.optimize.optimize_reports import (generate_backtest_stats,
-                                                         store_backtest_stats)
-        from freqtrade.resolvers import StrategyResolver
-        asyncio.set_event_loop(asyncio.new_event_loop())
-        try:
-            # Reload strategy
-            lastconfig = ApiServer._bt['last_config']
-            strat = StrategyResolver.load_strategy(btconfig)
-            validate_config_consistency(btconfig)
 
-            if (
-                not ApiServer._bt['bt']
-                or lastconfig.get('timeframe') != strat.timeframe
-                or lastconfig.get('timeframe_detail') != btconfig.get('timeframe_detail')
-                or lastconfig.get('timerange') != btconfig['timerange']
-            ):
-                from freqtrade.optimize.backtesting import Backtesting
-                ApiServer._bt['bt'] = Backtesting(btconfig)
-                ApiServer._bt['bt'].load_bt_data_detail()
-            else:
-                ApiServer._bt['bt'].config = btconfig
-                ApiServer._bt['bt'].init_backtest()
-            # Only reload data if timeframe changed.
-            if (
-                not ApiServer._bt['data']
-                or not ApiServer._bt['timerange']
-                or lastconfig.get('timeframe') != strat.timeframe
-                or lastconfig.get('timerange') != btconfig['timerange']
-            ):
-                ApiServer._bt['data'], ApiServer._bt['timerange'] = ApiServer._bt[
-                    'bt'].load_bt_data()
-
-            lastconfig['timerange'] = btconfig['timerange']
-            lastconfig['timeframe'] = strat.timeframe
-            lastconfig['protections'] = btconfig.get('protections', [])
-            lastconfig['enable_protections'] = btconfig.get('enable_protections')
-            lastconfig['dry_run_wallet'] = btconfig.get('dry_run_wallet')
-
-            ApiServer._bt['bt'].enable_protections = btconfig.get('enable_protections', False)
-            ApiServer._bt['bt'].strategylist = [strat]
-            ApiServer._bt['bt'].results = {}
-            ApiServer._bt['bt'].load_prior_backtest()
-
-            ApiServer._bt['bt'].abort = False
-            if (ApiServer._bt['bt'].results and
-                    strat.get_strategy_name() in ApiServer._bt['bt'].results['strategy']):
-                # When previous result hash matches - reuse that result and skip backtesting.
-                logger.info(f'Reusing result of previous backtest for {strat.get_strategy_name()}')
-            else:
-                min_date, max_date = ApiServer._bt['bt'].backtest_one_strategy(
-                    strat, ApiServer._bt['data'], ApiServer._bt['timerange'])
-
-                ApiServer._bt['bt'].results = generate_backtest_stats(
-                    ApiServer._bt['data'], ApiServer._bt['bt'].all_results,
-                    min_date=min_date, max_date=max_date)
-
-            if btconfig.get('export', 'none') == 'trades':
-                store_backtest_stats(
-                    btconfig['exportfilename'], ApiServer._bt['bt'].results,
-                    datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
-                    )
-
-            logger.info("Backtest finished.")
-
-        except (Exception, OperationalException, DependencyException) as e:
-            logger.exception(f"Backtesting caused an error: {e}")
-            ApiServer._bt['bt_error'] = str(e)
-            pass
-        finally:
-            ApiServer._bgtask_running = False
-
-    background_tasks.add_task(run_backtest)
-    ApiServer._bgtask_running = True
+    background_tasks.add_task(__run_backtest_bg, btconfig=btconfig)
+    ApiBG.bgtask_running = True
 
     return {
         "status": "running",
@@ -145,18 +149,18 @@ def api_get_backtest(ws_mode=Depends(is_webserver_mode)):
     Returns Result after backtesting has been ran.
     """
     from freqtrade.persistence import LocalTrade
-    if ApiServer._bgtask_running:
+    if ApiBG.bgtask_running:
         return {
             "status": "running",
             "running": True,
-            "step": (ApiServer._bt['bt'].progress.action if ApiServer._bt['bt']
+            "step": (ApiBG.bt['bt'].progress.action if ApiBG.bt['bt']
                      else str(BacktestState.STARTUP)),
-            "progress": ApiServer._bt['bt'].progress.progress if ApiServer._bt['bt'] else 0,
+            "progress": ApiBG.bt['bt'].progress.progress if ApiBG.bt['bt'] else 0,
             "trade_count": len(LocalTrade.trades),
             "status_msg": "Backtest running",
         }
 
-    if not ApiServer._bt['bt']:
+    if not ApiBG.bt['bt']:
         return {
             "status": "not_started",
             "running": False,
@@ -164,13 +168,13 @@ def api_get_backtest(ws_mode=Depends(is_webserver_mode)):
             "progress": 0,
             "status_msg": "Backtest not yet executed"
         }
-    if ApiServer._bt['bt_error']:
+    if ApiBG.bt['bt_error']:
         return {
             "status": "error",
             "running": False,
             "step": "",
             "progress": 0,
-            "status_msg": f"Backtest failed with {ApiServer._bt['bt_error']}"
+            "status_msg": f"Backtest failed with {ApiBG.bt['bt_error']}"
         }
 
     return {
@@ -179,14 +183,14 @@ def api_get_backtest(ws_mode=Depends(is_webserver_mode)):
         "status_msg": "Backtest ended",
         "step": "finished",
         "progress": 1,
-        "backtest_result": ApiServer._bt['bt'].results,
+        "backtest_result": ApiBG.bt['bt'].results,
     }
 
 
 @router.delete('/backtest', response_model=BacktestResponse, tags=['webserver', 'backtest'])
 def api_delete_backtest(ws_mode=Depends(is_webserver_mode)):
     """Reset backtesting"""
-    if ApiServer._bgtask_running:
+    if ApiBG.bgtask_running:
         return {
             "status": "running",
             "running": True,
@@ -194,12 +198,12 @@ def api_delete_backtest(ws_mode=Depends(is_webserver_mode)):
             "progress": 0,
             "status_msg": "Backtest running",
         }
-    if ApiServer._bt['bt']:
-        ApiServer._bt['bt'].cleanup()
-        del ApiServer._bt['bt']
-        ApiServer._bt['bt'] = None
-        del ApiServer._bt['data']
-        ApiServer._bt['data'] = None
+    if ApiBG.bt['bt']:
+        ApiBG.bt['bt'].cleanup()
+        del ApiBG.bt['bt']
+        ApiBG.bt['bt'] = None
+        del ApiBG.bt['data']
+        ApiBG.bt['data'] = None
         logger.info("Backtesting reset")
     return {
         "status": "reset",
@@ -212,7 +216,7 @@ def api_delete_backtest(ws_mode=Depends(is_webserver_mode)):
 
 @router.get('/backtest/abort', response_model=BacktestResponse, tags=['webserver', 'backtest'])
 def api_backtest_abort(ws_mode=Depends(is_webserver_mode)):
-    if not ApiServer._bgtask_running:
+    if not ApiBG.bgtask_running:
         return {
             "status": "not_running",
             "running": False,
@@ -220,7 +224,7 @@ def api_backtest_abort(ws_mode=Depends(is_webserver_mode)):
             "progress": 0,
             "status_msg": "Backtest ended",
         }
-    ApiServer._bt['bt'].abort = True
+    ApiBG.bt['bt'].abort = True
     return {
         "status": "stopping",
         "running": False,
diff --git a/freqtrade/rpc/api_server/api_schemas.py b/freqtrade/rpc/api_server/api_schemas.py
index 53bf7558f..a081f9fe9 100644
--- a/freqtrade/rpc/api_server/api_schemas.py
+++ b/freqtrade/rpc/api_server/api_schemas.py
@@ -36,20 +36,25 @@ class Balance(BaseModel):
     free: float
     balance: float
     used: float
+    bot_owned: Optional[float]
     est_stake: float
+    est_stake_bot: Optional[float]
     stake: str
     # Starting with 2.x
     side: str
     leverage: float
     is_position: bool
     position: float
+    is_bot_managed: bool
 
 
 class Balances(BaseModel):
     currencies: List[Balance]
     total: float
+    total_bot: float
     symbol: str
     value: float
+    value_bot: float
     stake: str
     note: str
     starting_capital: float
@@ -95,8 +100,10 @@ class Profit(BaseModel):
     trade_count: int
     closed_trade_count: int
     first_trade_date: str
+    first_trade_humanized: str
     first_trade_timestamp: int
     latest_trade_date: str
+    latest_trade_humanized: str
     latest_trade_timestamp: int
     avg_duration: str
     best_pair: str
diff --git a/freqtrade/rpc/api_server/api_v1.py b/freqtrade/rpc/api_server/api_v1.py
index 8aa706e62..2354c4bf8 100644
--- a/freqtrade/rpc/api_server/api_v1.py
+++ b/freqtrade/rpc/api_server/api_v1.py
@@ -43,7 +43,10 @@ logger = logging.getLogger(__name__)
 # 2.23: Allow plot config request in webserver mode
 # 2.24: Add cancel_open_order endpoint
 # 2.25: Add several profit values to /status endpoint
-API_VERSION = 2.25
+# 2.26: increase /balance output
+# 2.27: Add /trades/<id>/reload endpoint
+# 2.28: Switch reload endpoint to Post
+API_VERSION = 2.28
 
 # Public API, requires no auth.
 router_public = APIRouter()
@@ -126,11 +129,17 @@ def trades_delete(tradeid: int, rpc: RPC = Depends(get_rpc)):
 
 
 @router.delete('/trades/{tradeid}/open-order', response_model=OpenTradeSchema,  tags=['trading'])
-def cancel_open_order(tradeid: int, rpc: RPC = Depends(get_rpc)):
+def trade_cancel_open_order(tradeid: int, rpc: RPC = Depends(get_rpc)):
     rpc._rpc_cancel_open_order(tradeid)
     return rpc._rpc_trade_status([tradeid])[0]
 
 
+@router.post('/trades/{tradeid}/reload', response_model=OpenTradeSchema,  tags=['trading'])
+def trade_reload(tradeid: int, rpc: RPC = Depends(get_rpc)):
+    rpc._rpc_reload_trade_from_exchange(tradeid)
+    return rpc._rpc_trade_status([tradeid])[0]
+
+
 # TODO: Missing response model
 @router.get('/edge', tags=['info'])
 def edge(rpc: RPC = Depends(get_rpc)):
@@ -246,14 +255,17 @@ def pair_candles(
 
 @router.get('/pair_history', response_model=PairHistory, tags=['candle data'])
 def pair_history(pair: str, timeframe: str, timerange: str, strategy: str,
+                 freqaimodel: Optional[str] = None,
                  config=Depends(get_config), exchange=Depends(get_exchange)):
     # The initial call to this endpoint can be slow, as it may need to initialize
     # the exchange class.
     config = deepcopy(config)
     config.update({
         'strategy': strategy,
+        'timerange': timerange,
+        'freqaimodel': freqaimodel if freqaimodel else config.get('freqaimodel'),
     })
-    return RPC._rpc_analysed_history_full(config, pair, timeframe, timerange, exchange)
+    return RPC._rpc_analysed_history_full(config, pair, timeframe, exchange)
 
 
 @router.get('/plot_config', response_model=PlotConfig, tags=['candle data'])
diff --git a/freqtrade/rpc/api_server/deps.py b/freqtrade/rpc/api_server/deps.py
index f5b1bcd74..8fd105d3e 100644
--- a/freqtrade/rpc/api_server/deps.py
+++ b/freqtrade/rpc/api_server/deps.py
@@ -6,6 +6,7 @@ from fastapi import Depends
 from freqtrade.enums import RunMode
 from freqtrade.persistence import Trade
 from freqtrade.persistence.models import _request_id_ctx_var
+from freqtrade.rpc.api_server.webserver_bgwork import ApiBG
 from freqtrade.rpc.rpc import RPC, RPCException
 
 from .webserver import ApiServer
@@ -43,11 +44,11 @@ def get_api_config() -> Dict[str, Any]:
 
 
 def get_exchange(config=Depends(get_config)):
-    if not ApiServer._exchange:
+    if not ApiBG.exchange:
         from freqtrade.resolvers import ExchangeResolver
-        ApiServer._exchange = ExchangeResolver.load_exchange(
-            config['exchange']['name'], config, load_leverage_tiers=False)
-    return ApiServer._exchange
+        ApiBG.exchange = ExchangeResolver.load_exchange(
+            config, load_leverage_tiers=False)
+    return ApiBG.exchange
 
 
 def get_message_stream():
diff --git a/freqtrade/rpc/api_server/webserver.py b/freqtrade/rpc/api_server/webserver.py
index 8030e303b..165849a7f 100644
--- a/freqtrade/rpc/api_server/webserver.py
+++ b/freqtrade/rpc/api_server/webserver.py
@@ -1,6 +1,6 @@
 import logging
 from ipaddress import IPv4Address
-from typing import Any, Dict, Optional
+from typing import Any, Optional
 
 import orjson
 import uvicorn
@@ -36,19 +36,8 @@ class ApiServer(RPCHandler):
     __initialized = False
 
     _rpc: RPC
-    # Backtesting type: Backtesting
-    _bt: Dict[str, Any] = {
-        'bt': None,
-        'data': None,
-        'timerange': None,
-        'last_config': {},
-        'bt_error': None,
-    }
     _has_rpc: bool = False
-    _bgtask_running: bool = False
     _config: Config = {}
-    # Exchange - only available in webserver mode.
-    _exchange = None
     # websocket message stuff
     _message_stream: Optional[MessageStream] = None
 
@@ -85,7 +74,7 @@ class ApiServer(RPCHandler):
         """
         Attach rpc handler
         """
-        if not self._has_rpc:
+        if not ApiServer._has_rpc:
             ApiServer._rpc = rpc
             ApiServer._has_rpc = True
         else:
diff --git a/freqtrade/rpc/api_server/webserver_bgwork.py b/freqtrade/rpc/api_server/webserver_bgwork.py
new file mode 100644
index 000000000..925f34de3
--- /dev/null
+++ b/freqtrade/rpc/api_server/webserver_bgwork.py
@@ -0,0 +1,16 @@
+
+from typing import Any, Dict
+
+
+class ApiBG():
+    # Backtesting type: Backtesting
+    bt: Dict[str, Any] = {
+        'bt': None,
+        'data': None,
+        'timerange': None,
+        'last_config': {},
+        'bt_error': None,
+    }
+    bgtask_running: bool = False
+    # Exchange - only available in webserver mode.
+    exchange = None
diff --git a/freqtrade/rpc/rpc.py b/freqtrade/rpc/rpc.py
index 814f0d6a8..dedb35503 100644
--- a/freqtrade/rpc/rpc.py
+++ b/freqtrade/rpc/rpc.py
@@ -7,7 +7,6 @@ from datetime import date, datetime, timedelta, timezone
 from math import isnan
 from typing import Any, Dict, Generator, List, Optional, Sequence, Tuple, Union
 
-import arrow
 import psutil
 from dateutil.relativedelta import relativedelta
 from dateutil.tz import tzlocal
@@ -26,12 +25,13 @@ from freqtrade.exceptions import ExchangeError, PricingError
 from freqtrade.exchange import timeframe_to_minutes, timeframe_to_msecs
 from freqtrade.exchange.types import Tickers
 from freqtrade.loggers import bufferHandler
-from freqtrade.misc import decimals_per_coin, shorten_date
+from freqtrade.misc import decimals_per_coin
 from freqtrade.persistence import KeyStoreKeys, KeyValueStore, Order, PairLocks, Trade
 from freqtrade.persistence.models import PairLock
 from freqtrade.plugins.pairlist.pairlist_helpers import expand_pairlist
 from freqtrade.rpc.fiat_convert import CryptoToFiatConverter
 from freqtrade.rpc.rpc_types import RPCSendMsg
+from freqtrade.util import dt_humanize, dt_now, shorten_date
 from freqtrade.wallets import PositionWallet, Wallet
 
 
@@ -292,7 +292,7 @@ class RPC:
                                   and open_order.ft_order_side == trade.entry_side) else '')
                     + ('**' if (open_order and
                                 open_order.ft_order_side == trade.exit_side is not None) else ''),
-                    shorten_date(arrow.get(trade.open_date).humanize(only_distance=True)),
+                    shorten_date(dt_humanize(trade.open_date, only_distance=True)),
                     profit_str
                 ]
                 if self._config.get('position_adjustment_enable', False):
@@ -420,16 +420,15 @@ class RPC:
             else:
                 return 'draws'
         trades = Trade.get_trades([Trade.is_open.is_(False)], include_orders=False)
-        # Sell reason
+        # Duration
+        dur: Dict[str, List[float]] = {'wins': [], 'draws': [], 'losses': []}
+        # Exit reason
         exit_reasons = {}
         for trade in trades:
             if trade.exit_reason not in exit_reasons:
                 exit_reasons[trade.exit_reason] = {'wins': 0, 'losses': 0, 'draws': 0}
             exit_reasons[trade.exit_reason][trade_win_loss(trade)] += 1
 
-        # Duration
-        dur: Dict[str, List[float]] = {'wins': [], 'draws': [], 'losses': []}
-        for trade in trades:
             if trade.close_date is not None and trade.open_date is not None:
                 trade_dur = (trade.close_date - trade.open_date).total_seconds()
                 dur[trade_win_loss(trade)].append(trade_dur)
@@ -541,8 +540,8 @@ class RPC:
             fiat_display_currency
         ) if self._fiat_converter else 0
 
-        first_date = trades[0].open_date if trades else None
-        last_date = trades[-1].open_date if trades else None
+        first_date = trades[0].open_date_utc if trades else None
+        last_date = trades[-1].open_date_utc if trades else None
         num = float(len(durations) or 1)
         bot_start = KeyValueStore.get_datetime_value(KeyStoreKeys.BOT_START_TIME)
         return {
@@ -564,9 +563,11 @@ class RPC:
             'profit_all_fiat': profit_all_fiat,
             'trade_count': len(trades),
             'closed_trade_count': len([t for t in trades if not t.is_open]),
-            'first_trade_date': arrow.get(first_date).humanize() if first_date else '',
+            'first_trade_date': first_date.strftime(DATETIME_PRINT_FORMAT) if first_date else '',
+            'first_trade_humanized': dt_humanize(first_date) if first_date else '',
             'first_trade_timestamp': int(first_date.timestamp() * 1000) if first_date else 0,
-            'latest_trade_date': arrow.get(last_date).humanize() if last_date else '',
+            'latest_trade_date': last_date.strftime(DATETIME_PRINT_FORMAT) if last_date else '',
+            'latest_trade_humanized': dt_humanize(last_date) if last_date else '',
             'latest_trade_timestamp': int(last_date.timestamp() * 1000) if last_date else 0,
             'avg_duration': str(timedelta(seconds=sum(durations) / num)).split('.')[0],
             'best_pair': best_pair[0] if best_pair else '',
@@ -583,13 +584,16 @@ class RPC:
         }
 
     def __balance_get_est_stake(
-            self, coin: str, stake_currency: str, balance: Wallet, tickers) -> float:
+            self, coin: str, stake_currency: str, amount: float,
+            balance: Wallet, tickers) -> Tuple[float, float]:
         est_stake = 0.0
+        est_bot_stake = 0.0
         if coin == stake_currency:
             est_stake = balance.total
             if self._config.get('trading_mode', TradingMode.SPOT) != TradingMode.SPOT:
                 # in Futures, "total" includes the locked stake, and therefore all positions
                 est_stake = balance.free
+            est_bot_stake = amount
         else:
             try:
                 pair = self._freqtrade.exchange.get_valid_pair_combination(coin, stake_currency)
@@ -598,11 +602,12 @@ class RPC:
                     if pair.startswith(stake_currency) and not pair.endswith(stake_currency):
                         rate = 1.0 / rate
                     est_stake = rate * balance.total
+                    est_bot_stake = rate * amount
             except (ExchangeError):
                 logger.warning(f"Could not get rate for pair {coin}.")
                 raise ValueError()
 
-        return est_stake
+        return est_stake, est_bot_stake
 
     def _rpc_balance(self, stake_currency: str, fiat_display_currency: str) -> Dict:
         """ Returns current account balance per crypto """
@@ -615,7 +620,7 @@ class RPC:
             raise RPCException('Error getting current tickers.')
 
         open_trades: List[Trade] = Trade.get_open_trades()
-        open_assets = [t.base_currency for t in open_trades]
+        open_assets: Dict[str, Trade] = {t.safe_base_currency: t for t in open_trades}
         self._freqtrade.wallets.update(require_update=False)
         starting_capital = self._freqtrade.wallets.get_starting_balance()
         starting_cap_fiat = self._fiat_converter.convert_amount(
@@ -625,30 +630,43 @@ class RPC:
         for coin, balance in self._freqtrade.wallets.get_all_balances().items():
             if not balance.total:
                 continue
+
+            trade = open_assets.get(coin, None)
+            is_bot_managed = coin == stake_currency or trade is not None
+            trade_amount = trade.amount if trade else 0
+            if coin == stake_currency:
+                trade_amount = self._freqtrade.wallets.get_available_stake_amount()
+
             try:
-                est_stake = self.__balance_get_est_stake(coin, stake_currency, balance, tickers)
+                est_stake, est_stake_bot = self.__balance_get_est_stake(
+                    coin, stake_currency, trade_amount, balance, tickers)
             except ValueError:
                 continue
 
             total += est_stake
-            if coin == stake_currency or coin in open_assets:
-                total_bot += est_stake
+
+            if is_bot_managed:
+                total_bot += est_stake_bot
             currencies.append({
                 'currency': coin,
                 'free': balance.free,
                 'balance': balance.total,
                 'used': balance.used,
+                'bot_owned': trade_amount,
                 'est_stake': est_stake or 0,
+                'est_stake_bot': est_stake_bot if is_bot_managed else 0,
                 'stake': stake_currency,
                 'side': 'long',
                 'leverage': 1,
                 'position': 0,
+                'is_bot_managed': is_bot_managed,
                 'is_position': False,
             })
         symbol: str
         position: PositionWallet
         for symbol, position in self._freqtrade.wallets.get_all_positions().items():
             total += position.collateral
+            total_bot += position.collateral
 
             currencies.append({
                 'currency': symbol,
@@ -657,9 +675,11 @@ class RPC:
                 'used': 0,
                 'position': position.position,
                 'est_stake': position.collateral,
+                'est_stake_bot': position.collateral,
                 'stake': stake_currency,
                 'leverage': position.leverage,
                 'side': position.side,
+                'is_bot_managed': True,
                 'is_position': True
             })
 
@@ -675,8 +695,10 @@ class RPC:
         return {
             'currencies': currencies,
             'total': total,
+            'total_bot': total_bot,
             'symbol': fiat_display_currency,
             'value': value,
+            'value_bot': value_bot,
             'stake': stake_currency,
             'starting_capital': starting_capital,
             'starting_capital_ratio': starting_capital_ratio,
@@ -720,6 +742,18 @@ class RPC:
 
         return {'status': 'No more entries will occur from now. Run /reload_config to reset.'}
 
+    def _rpc_reload_trade_from_exchange(self, trade_id: int) -> Dict[str, str]:
+        """
+        Handler for reload_trade_from_exchange.
+        Reloads a trade from it's orders, should manual interaction have happened.
+        """
+        trade = Trade.get_trades(trade_filter=[Trade.id == trade_id]).first()
+        if not trade:
+            raise RPCException(f"Could not find trade with id {trade_id}.")
+
+        self._freqtrade.handle_onexchange_order(trade)
+        return {'status': 'Reloaded from orders from exchange'}
+
     def __exec_force_exit(self, trade: Trade, ordertype: Optional[str],
                           amount: Optional[float] = None) -> None:
         # Check if there is there is an open order
@@ -1195,8 +1229,8 @@ class RPC:
 
     @staticmethod
     def _rpc_analysed_history_full(config: Config, pair: str, timeframe: str,
-                                   timerange: str, exchange) -> Dict[str, Any]:
-        timerange_parsed = TimeRange.parse_timerange(timerange)
+                                   exchange) -> Dict[str, Any]:
+        timerange_parsed = TimeRange.parse_timerange(config.get('timerange'))
 
         _data = load_data(
             datadir=config["datadir"],
@@ -1207,7 +1241,8 @@ class RPC:
             candle_type=config.get('candle_type_def', CandleType.SPOT)
         )
         if pair not in _data:
-            raise RPCException(f"No data for {pair}, {timeframe} in {timerange} found.")
+            raise RPCException(
+                f"No data for {pair}, {timeframe} in {config.get('timerange')} found.")
         from freqtrade.data.dataprovider import DataProvider
         from freqtrade.resolvers.strategy_resolver import StrategyResolver
         strategy = StrategyResolver.load_strategy(config)
@@ -1217,7 +1252,7 @@ class RPC:
         df_analyzed = strategy.analyze_ticker(_data[pair], {'pair': pair})
 
         return RPC._convert_dataframe_to_dict(strategy.get_strategy_name(), pair, timeframe,
-                                              df_analyzed, arrow.Arrow.utcnow().datetime)
+                                              df_analyzed, dt_now())
 
     def _rpc_plot_config(self) -> Dict[str, Any]:
         if (self._freqtrade.strategy.plot_config and
diff --git a/freqtrade/rpc/telegram.py b/freqtrade/rpc/telegram.py
index e626ee598..d082299cb 100644
--- a/freqtrade/rpc/telegram.py
+++ b/freqtrade/rpc/telegram.py
@@ -3,6 +3,7 @@
 """
 This module manage Telegram communication
 """
+import asyncio
 import json
 import logging
 import re
@@ -13,15 +14,16 @@ from functools import partial
 from html import escape
 from itertools import chain
 from math import isnan
-from typing import Any, Callable, Dict, List, Optional, Union
+from threading import Thread
+from typing import Any, Callable, Coroutine, Dict, List, Optional, Union
 
-import arrow
 from tabulate import tabulate
-from telegram import (MAX_MESSAGE_LENGTH, CallbackQuery, InlineKeyboardButton, InlineKeyboardMarkup,
-                      KeyboardButton, ParseMode, ReplyKeyboardMarkup, Update)
+from telegram import (CallbackQuery, InlineKeyboardButton, InlineKeyboardMarkup, KeyboardButton,
+                      ReplyKeyboardMarkup, Update)
+from telegram.constants import MessageLimit, ParseMode
 from telegram.error import BadRequest, NetworkError, TelegramError
-from telegram.ext import CallbackContext, CallbackQueryHandler, CommandHandler, Updater
-from telegram.utils.helpers import escape_markdown
+from telegram.ext import Application, CallbackContext, CallbackQueryHandler, CommandHandler
+from telegram.helpers import escape_markdown
 
 from freqtrade.__init__ import __version__
 from freqtrade.constants import DUST_PER_COIN, Config
@@ -31,6 +33,10 @@ from freqtrade.misc import chunks, plural, round_coin_value
 from freqtrade.persistence import Trade
 from freqtrade.rpc import RPC, RPCException, RPCHandler
 from freqtrade.rpc.rpc_types import RPCSendMsg
+from freqtrade.util import dt_humanize
+
+
+MAX_MESSAGE_LENGTH = MessageLimit.MAX_TEXT_LENGTH
 
 
 logger = logging.getLogger(__name__)
@@ -47,14 +53,14 @@ class TimeunitMappings:
     default: int
 
 
-def authorized_only(command_handler: Callable[..., None]) -> Callable[..., Any]:
+def authorized_only(command_handler: Callable[..., Coroutine[Any, Any, None]]):
     """
     Decorator to check if the message comes from the correct chat_id
     :param command_handler: Telegram CommandHandler
     :return: decorated function
     """
 
-    def wrapper(self, *args, **kwargs):
+    async def wrapper(self, *args, **kwargs):
         """ Decorator logic """
         update = kwargs.get('update') or args[0]
 
@@ -76,9 +82,9 @@ def authorized_only(command_handler: Callable[..., None]) -> Callable[..., Any]:
             chat_id
         )
         try:
-            return command_handler(self, *args, **kwargs)
+            return await command_handler(self, *args, **kwargs)
         except RPCException as e:
-            self._send_msg(str(e))
+            await self._send_msg(str(e))
         except BaseException:
             logger.exception('Exception occurred within Telegram module')
         finally:
@@ -99,9 +105,17 @@ class Telegram(RPCHandler):
         """
         super().__init__(rpc, config)
 
-        self._updater: Updater
+        self._app: Application
+        self._loop: asyncio.AbstractEventLoop
         self._init_keyboard()
-        self._init()
+        self._start_thread()
+
+    def _start_thread(self):
+        """
+        Creates and starts the polling thread
+        """
+        self._thread = Thread(target=self._init, name='FTTelegram')
+        self._thread.start()
 
     def _init_keyboard(self) -> None:
         """
@@ -152,14 +166,23 @@ class Telegram(RPCHandler):
                 logger.info('using custom keyboard from '
                             f'config.json: {self._keyboard}')
 
+    def _init_telegram_app(self):
+        return Application.builder().token(self._config['telegram']['token']).build()
+
     def _init(self) -> None:
         """
         Initializes this module with the given config,
         registers all known command handlers
         and starts polling for message updates
+        Runs in a separate thread.
         """
-        self._updater = Updater(token=self._config['telegram']['token'], workers=0,
-                                use_context=True)
+        try:
+            self._loop = asyncio.get_running_loop()
+        except RuntimeError:
+            self._loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(self._loop)
+
+        self._app = self._init_telegram_app()
 
         # Register command handler and start telegram message polling
         handles = [
@@ -173,6 +196,7 @@ class Telegram(RPCHandler):
                 self._force_enter, order_side=SignalDirection.LONG)),
             CommandHandler('forceshort', partial(
                 self._force_enter, order_side=SignalDirection.SHORT)),
+            CommandHandler('reload_trade', self._reload_trade_from_exchange),
             CommandHandler('trades', self._trades),
             CommandHandler('delete', self._delete_trade),
             CommandHandler(['coo', 'cancel_open_order'], self._cancel_open_order),
@@ -218,21 +242,38 @@ class Telegram(RPCHandler):
             CallbackQueryHandler(self._force_enter_inline, pattern=r"\S+\/\S+"),
         ]
         for handle in handles:
-            self._updater.dispatcher.add_handler(handle)
+            self._app.add_handler(handle)
 
         for callback in callbacks:
-            self._updater.dispatcher.add_handler(callback)
+            self._app.add_handler(callback)
 
-        self._updater.start_polling(
-            bootstrap_retries=-1,
-            timeout=20,
-            read_latency=60,  # Assumed transmission latency
-            drop_pending_updates=True,
-        )
         logger.info(
             'rpc.telegram is listening for following commands: %s',
-            [h.command for h in handles]
+            [[x for x in sorted(h.commands)] for h in handles]
         )
+        self._loop.run_until_complete(self._startup_telegram())
+
+    async def _startup_telegram(self) -> None:
+        await self._app.initialize()
+        await self._app.start()
+        if self._app.updater:
+            await self._app.updater.start_polling(
+                bootstrap_retries=-1,
+                timeout=20,
+                # read_latency=60,  # Assumed transmission latency
+                drop_pending_updates=True,
+                # stop_signals=[],  # Necessary as we don't run on the main thread
+            )
+            while True:
+                await asyncio.sleep(10)
+                if not self._app.updater.running:
+                    break
+
+    async def _cleanup_telegram(self) -> None:
+        if self._app.updater:
+            await self._app.updater.stop()
+        await self._app.stop()
+        await self._app.shutdown()
 
     def cleanup(self) -> None:
         """
@@ -240,7 +281,8 @@ class Telegram(RPCHandler):
         :return: None
         """
         # This can take up to `timeout` from the call to `start_polling`.
-        self._updater.stop()
+        asyncio.run_coroutine_threadsafe(self._cleanup_telegram(), self._loop)
+        self._thread.join()
 
     def _exchange_from_msg(self, msg: Dict[str, Any]) -> str:
         """
@@ -453,7 +495,9 @@ class Telegram(RPCHandler):
 
         message = self.compose_message(deepcopy(msg), msg_type)  # type: ignore
         if message:
-            self._send_msg(message, disable_notification=(noti == 'silent'))
+            asyncio.run_coroutine_threadsafe(
+                self._send_msg(message, disable_notification=(noti == 'silent')),
+                self._loop)
 
     def _get_sell_emoji(self, msg):
         """
@@ -484,7 +528,6 @@ class Telegram(RPCHandler):
             order_nr += 1
             wording = 'Entry' if order['ft_is_entry'] else 'Exit'
 
-            cur_entry_datetime = arrow.get(order["order_filled_date"])
             cur_entry_amount = order["filled"] or order["amount"]
             cur_entry_average = order["safe_price"]
             lines.append("  ")
@@ -515,28 +558,20 @@ class Telegram(RPCHandler):
 
                 lines.append(f"*{wording} #{order_nr}:* at {minus_on_entry:.2%} avg Profit")
                 if is_open:
-                    lines.append("({})".format(cur_entry_datetime
-                                               .humanize(granularity=["day", "hour", "minute"])))
+                    lines.append("({})".format(dt_humanize(order["order_filled_date"],
+                                                           granularity=["day", "hour", "minute"])))
                 lines.append(f"*Amount:* {cur_entry_amount} "
                              f"({round_coin_value(order['cost'], quote_currency)})")
                 lines.append(f"*Average {wording} Price:* {cur_entry_average} "
                              f"({price_to_1st_entry:.2%} from 1st entry Rate)")
                 lines.append(f"*Order filled:* {order['order_filled_date']}")
 
-                # TODO: is this really useful?
-                # dur_entry = cur_entry_datetime - arrow.get(
-                #     filled_orders[x - 1]["order_filled_date"])
-                # days = dur_entry.days
-                # hours, remainder = divmod(dur_entry.seconds, 3600)
-                # minutes, seconds = divmod(remainder, 60)
-                # lines.append(
-                # f"({days}d {hours}h {minutes}m {seconds}s from previous {wording.lower()})")
             lines_detail.append("\n".join(lines))
 
         return lines_detail
 
     @authorized_only
-    def _status(self, update: Update, context: CallbackContext) -> None:
+    async def _status(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /status.
         Returns the current TradeThread status
@@ -546,12 +581,12 @@ class Telegram(RPCHandler):
         """
 
         if context.args and 'table' in context.args:
-            self._status_table(update, context)
+            await self._status_table(update, context)
             return
         else:
-            self._status_msg(update, context)
+            await self._status_msg(update, context)
 
-    def _status_msg(self, update: Update, context: CallbackContext) -> None:
+    async def _status_msg(self, update: Update, context: CallbackContext) -> None:
         """
         handler for `/status` and `/status <id>`.
 
@@ -566,7 +601,7 @@ class Telegram(RPCHandler):
         position_adjust = self._config.get('position_adjustment_enable', False)
         max_entries = self._config.get('max_entry_position_adjustment', -1)
         for r in results:
-            r['open_date_hum'] = arrow.get(r['open_date']).humanize()
+            r['open_date_hum'] = dt_humanize(r['open_date'])
             r['num_entries'] = len([o for o in r['orders'] if o['ft_is_entry']])
             r['num_exits'] = len([o for o in r['orders'] if not o['ft_is_entry']
                                  and not o['ft_order_side'] == 'stoploss'])
@@ -635,9 +670,9 @@ class Telegram(RPCHandler):
             lines_detail = self._prepare_order_details(
                 r['orders'], r['quote_currency'], r['is_open'])
             lines.extend(lines_detail if lines_detail else "")
-            self.__send_status_msg(lines, r)
+            await self.__send_status_msg(lines, r)
 
-    def __send_status_msg(self, lines: List[str], r: Dict[str, Any]) -> None:
+    async def __send_status_msg(self, lines: List[str], r: Dict[str, Any]) -> None:
         """
         Send status message.
         """
@@ -648,13 +683,13 @@ class Telegram(RPCHandler):
                 if (len(msg) + len(line) + 1) < MAX_MESSAGE_LENGTH:
                     msg += line + '\n'
                 else:
-                    self._send_msg(msg.format(**r))
+                    await self._send_msg(msg.format(**r))
                     msg = "*Trade ID:* `{trade_id}` - continued\n" + line + '\n'
 
-        self._send_msg(msg.format(**r))
+        await self._send_msg(msg.format(**r))
 
     @authorized_only
-    def _status_table(self, update: Update, context: CallbackContext) -> None:
+    async def _status_table(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /status table.
         Returns the current TradeThread status in table format
@@ -687,12 +722,11 @@ class Telegram(RPCHandler):
                 # insert separators line between Total
                 lines = message.split("\n")
                 message = "\n".join(lines[:-1] + [lines[1]] + [lines[-1]])
-            self._send_msg(f"<pre>{message}</pre>", parse_mode=ParseMode.HTML,
-                           reload_able=True, callback_path="update_status_table",
-                           query=update.callback_query)
+            await self._send_msg(f"<pre>{message}</pre>", parse_mode=ParseMode.HTML,
+                                 reload_able=True, callback_path="update_status_table",
+                                 query=update.callback_query)
 
-    @authorized_only
-    def _timeunit_stats(self, update: Update, context: CallbackContext, unit: str) -> None:
+    async def _timeunit_stats(self, update: Update, context: CallbackContext, unit: str) -> None:
         """
         Handler for /daily <n>
         Returns a daily profit (in BTC) over the last n days.
@@ -739,11 +773,11 @@ class Telegram(RPCHandler):
             f'<b>{val.message} Profit over the last {timescale} {val.message2}</b>:\n'
             f'<pre>{stats_tab}</pre>'
         )
-        self._send_msg(message, parse_mode=ParseMode.HTML, reload_able=True,
-                       callback_path=val.callback, query=update.callback_query)
+        await self._send_msg(message, parse_mode=ParseMode.HTML, reload_able=True,
+                             callback_path=val.callback, query=update.callback_query)
 
     @authorized_only
-    def _daily(self, update: Update, context: CallbackContext) -> None:
+    async def _daily(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /daily <n>
         Returns a daily profit (in BTC) over the last n days.
@@ -751,10 +785,10 @@ class Telegram(RPCHandler):
         :param update: message update
         :return: None
         """
-        self._timeunit_stats(update, context, 'days')
+        await self._timeunit_stats(update, context, 'days')
 
     @authorized_only
-    def _weekly(self, update: Update, context: CallbackContext) -> None:
+    async def _weekly(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /weekly <n>
         Returns a weekly profit (in BTC) over the last n weeks.
@@ -762,10 +796,10 @@ class Telegram(RPCHandler):
         :param update: message update
         :return: None
         """
-        self._timeunit_stats(update, context, 'weeks')
+        await self._timeunit_stats(update, context, 'weeks')
 
     @authorized_only
-    def _monthly(self, update: Update, context: CallbackContext) -> None:
+    async def _monthly(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /monthly <n>
         Returns a monthly profit (in BTC) over the last n months.
@@ -773,10 +807,10 @@ class Telegram(RPCHandler):
         :param update: message update
         :return: None
         """
-        self._timeunit_stats(update, context, 'months')
+        await self._timeunit_stats(update, context, 'months')
 
     @authorized_only
-    def _profit(self, update: Update, context: CallbackContext) -> None:
+    async def _profit(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /profit.
         Returns a cumulative profit statistics.
@@ -810,8 +844,8 @@ class Telegram(RPCHandler):
         profit_all_percent = stats['profit_all_percent']
         profit_all_fiat = stats['profit_all_fiat']
         trade_count = stats['trade_count']
-        first_trade_date = stats['first_trade_date']
-        latest_trade_date = stats['latest_trade_date']
+        first_trade_date = f"{stats['first_trade_humanized']} ({stats['first_trade_date']})"
+        latest_trade_date = f"{stats['latest_trade_humanized']} ({stats['latest_trade_date']})"
         avg_duration = stats['avg_duration']
         best_pair = stats['best_pair']
         best_pair_profit_ratio = stats['best_pair_profit_ratio']
@@ -850,11 +884,11 @@ class Telegram(RPCHandler):
                     f"*Max Drawdown:* `{stats['max_drawdown']:.2%} "
                     f"({round_coin_value(stats['max_drawdown_abs'], stake_cur)})`"
                 )
-        self._send_msg(markdown_msg, reload_able=True, callback_path="update_profit",
-                       query=update.callback_query)
+        await self._send_msg(markdown_msg, reload_able=True, callback_path="update_profit",
+                             query=update.callback_query)
 
     @authorized_only
-    def _stats(self, update: Update, context: CallbackContext) -> None:
+    async def _stats(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /stats
         Show stats of recent trades
@@ -885,7 +919,7 @@ class Telegram(RPCHandler):
                 headers=['Exit Reason', 'Exits', 'Wins', 'Losses']
             )
             if len(exit_reasons_tabulate) > 25:
-                self._send_msg(f"```\n{exit_reasons_msg}```", ParseMode.MARKDOWN)
+                await self._send_msg(f"```\n{exit_reasons_msg}```", ParseMode.MARKDOWN)
                 exit_reasons_msg = ''
 
         durations = stats['durations']
@@ -900,11 +934,12 @@ class Telegram(RPCHandler):
         )
         msg = (f"""```\n{exit_reasons_msg}```\n```\n{duration_msg}```""")
 
-        self._send_msg(msg, ParseMode.MARKDOWN)
+        await self._send_msg(msg, ParseMode.MARKDOWN)
 
     @authorized_only
-    def _balance(self, update: Update, context: CallbackContext) -> None:
+    async def _balance(self, update: Update, context: CallbackContext) -> None:
         """ Handler for /balance """
+        full_result = context.args and 'full' in context.args
         result = self._rpc._rpc_balance(self._config['stake_currency'],
                                         self._config.get('fiat_display_currency', ''))
 
@@ -915,8 +950,7 @@ class Telegram(RPCHandler):
         output = ''
         if self._config['dry_run']:
             output += "*Warning:* Simulated balances in Dry Mode.\n"
-        starting_cap = round_coin_value(
-            result['starting_capital'], self._config['stake_currency'])
+        starting_cap = round_coin_value(result['starting_capital'], self._config['stake_currency'])
         output += f"Starting capital: `{starting_cap}`"
         starting_cap_fiat = round_coin_value(
             result['starting_capital_fiat'], self._config['fiat_display_currency']
@@ -928,7 +962,10 @@ class Telegram(RPCHandler):
         total_dust_currencies = 0
         for curr in result['currencies']:
             curr_output = ''
-            if curr['est_stake'] > balance_dust_level:
+            if (
+                (curr['is_position'] or curr['est_stake'] > balance_dust_level)
+                and (full_result or curr['is_bot_managed'])
+            ):
                 if curr['is_position']:
                     curr_output = (
                         f"*{curr['currency']}:*\n"
@@ -937,20 +974,24 @@ class Telegram(RPCHandler):
                         f"\t`Est. {curr['stake']}: "
                         f"{round_coin_value(curr['est_stake'], curr['stake'], False)}`\n")
                 else:
+                    est_stake = round_coin_value(
+                        curr['est_stake' if full_result else 'est_stake_bot'], curr['stake'], False)
+
                     curr_output = (
                         f"*{curr['currency']}:*\n"
                         f"\t`Available: {curr['free']:.8f}`\n"
                         f"\t`Balance: {curr['balance']:.8f}`\n"
                         f"\t`Pending: {curr['used']:.8f}`\n"
-                        f"\t`Est. {curr['stake']}: "
-                        f"{round_coin_value(curr['est_stake'], curr['stake'], False)}`\n")
+                        f"\t`Bot Owned: {curr['bot_owned']:.8f}`\n"
+                        f"\t`Est. {curr['stake']}: {est_stake}`\n")
+
             elif curr['est_stake'] <= balance_dust_level:
                 total_dust_balance += curr['est_stake']
                 total_dust_currencies += 1
 
             # Handle overflowing message length
             if len(output + curr_output) >= MAX_MESSAGE_LENGTH:
-                self._send_msg(output)
+                await self._send_msg(output)
                 output = curr_output
             else:
                 output += curr_output
@@ -965,19 +1006,20 @@ class Telegram(RPCHandler):
         tc = result['trade_count'] > 0
         stake_improve = f" `({result['starting_capital_ratio']:.2%})`" if tc else ''
         fiat_val = f" `({result['starting_capital_fiat_ratio']:.2%})`" if tc else ''
-
-        output += ("\n*Estimated Value*:\n"
-                   f"\t`{result['stake']}: "
-                   f"{round_coin_value(result['total'], result['stake'], False)}`"
-                   f"{stake_improve}\n"
-                   f"\t`{result['symbol']}: "
-                   f"{round_coin_value(result['value'], result['symbol'], False)}`"
-                   f"{fiat_val}\n")
-        self._send_msg(output, reload_able=True, callback_path="update_balance",
-                       query=update.callback_query)
+        value = round_coin_value(
+            result['value' if full_result else 'value_bot'], result['symbol'], False)
+        total_stake = round_coin_value(
+            result['total' if full_result else 'total_bot'], result['stake'], False)
+        output += (
+            f"\n*Estimated Value{' (Bot managed assets only)' if not full_result else ''}*:\n"
+            f"\t`{result['stake']}: {total_stake}`{stake_improve}\n"
+            f"\t`{result['symbol']}: {value}`{fiat_val}\n"
+        )
+        await self._send_msg(output, reload_able=True, callback_path="update_balance",
+                             query=update.callback_query)
 
     @authorized_only
-    def _start(self, update: Update, context: CallbackContext) -> None:
+    async def _start(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /start.
         Starts TradeThread
@@ -986,10 +1028,10 @@ class Telegram(RPCHandler):
         :return: None
         """
         msg = self._rpc._rpc_start()
-        self._send_msg(f"Status: `{msg['status']}`")
+        await self._send_msg(f"Status: `{msg['status']}`")
 
     @authorized_only
-    def _stop(self, update: Update, context: CallbackContext) -> None:
+    async def _stop(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /stop.
         Stops TradeThread
@@ -998,10 +1040,10 @@ class Telegram(RPCHandler):
         :return: None
         """
         msg = self._rpc._rpc_stop()
-        self._send_msg(f"Status: `{msg['status']}`")
+        await self._send_msg(f"Status: `{msg['status']}`")
 
     @authorized_only
-    def _reload_config(self, update: Update, context: CallbackContext) -> None:
+    async def _reload_config(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /reload_config.
         Triggers a config file reload
@@ -1010,10 +1052,10 @@ class Telegram(RPCHandler):
         :return: None
         """
         msg = self._rpc._rpc_reload_config()
-        self._send_msg(f"Status: `{msg['status']}`")
+        await self._send_msg(f"Status: `{msg['status']}`")
 
     @authorized_only
-    def _stopentry(self, update: Update, context: CallbackContext) -> None:
+    async def _stopentry(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /stop_buy.
         Sets max_open_trades to 0 and gracefully sells all open trades
@@ -1022,10 +1064,21 @@ class Telegram(RPCHandler):
         :return: None
         """
         msg = self._rpc._rpc_stopentry()
-        self._send_msg(f"Status: `{msg['status']}`")
+        await self._send_msg(f"Status: `{msg['status']}`")
 
     @authorized_only
-    def _force_exit(self, update: Update, context: CallbackContext) -> None:
+    async def _reload_trade_from_exchange(self, update: Update, context: CallbackContext) -> None:
+        """
+        Handler for /reload_trade <tradeid>.
+        """
+        if not context.args or len(context.args) == 0:
+            raise RPCException("Trade-id not set.")
+        trade_id = int(context.args[0])
+        msg = self._rpc._rpc_reload_trade_from_exchange(trade_id)
+        await self._send_msg(f"Status: `{msg['status']}`")
+
+    @authorized_only
+    async def _force_exit(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /forceexit <id>.
         Sells the given trade at current price
@@ -1036,14 +1089,14 @@ class Telegram(RPCHandler):
 
         if context.args:
             trade_id = context.args[0]
-            self._force_exit_action(trade_id)
+            await self._force_exit_action(trade_id)
         else:
             fiat_currency = self._config.get('fiat_display_currency', '')
             try:
                 statlist, _, _ = self._rpc._rpc_status_table(
                     self._config['stake_currency'], fiat_currency)
             except RPCException:
-                self._send_msg(msg='No open trade found.')
+                await self._send_msg(msg='No open trade found.')
                 return
             trades = []
             for trade in statlist:
@@ -1056,51 +1109,51 @@ class Telegram(RPCHandler):
 
             buttons_aligned.append([InlineKeyboardButton(
                 text='Cancel', callback_data='force_exit__cancel')])
-            self._send_msg(msg="Which trade?", keyboard=buttons_aligned)
+            await self._send_msg(msg="Which trade?", keyboard=buttons_aligned)
 
-    def _force_exit_action(self, trade_id):
+    async def _force_exit_action(self, trade_id):
         if trade_id != 'cancel':
             try:
                 self._rpc._rpc_force_exit(trade_id)
             except RPCException as e:
-                self._send_msg(str(e))
+                await self._send_msg(str(e))
 
-    def _force_exit_inline(self, update: Update, _: CallbackContext) -> None:
+    async def _force_exit_inline(self, update: Update, _: CallbackContext) -> None:
         if update.callback_query:
             query = update.callback_query
             if query.data and '__' in query.data:
                 # Input data is "force_exit__<tradid|cancel>"
                 trade_id = query.data.split("__")[1].split(' ')[0]
                 if trade_id == 'cancel':
-                    query.answer()
-                    query.edit_message_text(text="Force exit canceled.")
+                    await query.answer()
+                    await query.edit_message_text(text="Force exit canceled.")
                     return
                 trade: Optional[Trade] = Trade.get_trades(trade_filter=Trade.id == trade_id).first()
-                query.answer()
+                await query.answer()
                 if trade:
-                    query.edit_message_text(
+                    await query.edit_message_text(
                         text=f"Manually exiting Trade #{trade_id}, {trade.pair}")
-                    self._force_exit_action(trade_id)
+                    await self._force_exit_action(trade_id)
                 else:
-                    query.edit_message_text(text=f"Trade {trade_id} not found.")
+                    await query.edit_message_text(text=f"Trade {trade_id} not found.")
 
-    def _force_enter_action(self, pair, price: Optional[float], order_side: SignalDirection):
+    async def _force_enter_action(self, pair, price: Optional[float], order_side: SignalDirection):
         if pair != 'cancel':
             try:
                 self._rpc._rpc_force_entry(pair, price, order_side=order_side)
             except RPCException as e:
                 logger.exception("Forcebuy error!")
-                self._send_msg(str(e), ParseMode.HTML)
+                await self._send_msg(str(e), ParseMode.HTML)
 
-    def _force_enter_inline(self, update: Update, _: CallbackContext) -> None:
+    async def _force_enter_inline(self, update: Update, _: CallbackContext) -> None:
         if update.callback_query:
             query = update.callback_query
             if query.data and '_||_' in query.data:
                 pair, side = query.data.split('_||_')
                 order_side = SignalDirection(side)
-                query.answer()
-                query.edit_message_text(text=f"Manually entering {order_side} for {pair}")
-                self._force_enter_action(pair, None, order_side)
+                await query.answer()
+                await query.edit_message_text(text=f"Manually entering {order_side} for {pair}")
+                await self._force_enter_action(pair, None, order_side)
 
     @staticmethod
     def _layout_inline_keyboard(
@@ -1113,7 +1166,7 @@ class Telegram(RPCHandler):
         return [buttons[i:i + cols] for i in range(0, len(buttons), cols)]
 
     @authorized_only
-    def _force_enter(
+    async def _force_enter(
             self, update: Update, context: CallbackContext, order_side: SignalDirection) -> None:
         """
         Handler for /forcelong <asset> <price> and `/forceshort <asset> <price>
@@ -1125,7 +1178,7 @@ class Telegram(RPCHandler):
         if context.args:
             pair = context.args[0]
             price = float(context.args[1]) if len(context.args) > 1 else None
-            self._force_enter_action(pair, price, order_side)
+            await self._force_enter_action(pair, price, order_side)
         else:
             whitelist = self._rpc._rpc_whitelist()['whitelist']
             pair_buttons = [
@@ -1135,12 +1188,12 @@ class Telegram(RPCHandler):
             buttons_aligned = self._layout_inline_keyboard(pair_buttons)
 
             buttons_aligned.append([InlineKeyboardButton(text='Cancel', callback_data='cancel')])
-            self._send_msg(msg="Which pair?",
-                           keyboard=buttons_aligned,
-                           query=update.callback_query)
+            await self._send_msg(msg="Which pair?",
+                                 keyboard=buttons_aligned,
+                                 query=update.callback_query)
 
     @authorized_only
-    def _trades(self, update: Update, context: CallbackContext) -> None:
+    async def _trades(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /trades <n>
         Returns last n recent trades.
@@ -1157,7 +1210,7 @@ class Telegram(RPCHandler):
             nrecent
         )
         trades_tab = tabulate(
-            [[arrow.get(trade['close_date']).humanize(),
+            [[dt_humanize(trade['close_date']),
                 trade['pair'] + " (#" + str(trade['trade_id']) + ")",
                 f"{(trade['close_profit']):.2%} ({trade['close_profit_abs']})"]
                 for trade in trades['trades']],
@@ -1169,10 +1222,10 @@ class Telegram(RPCHandler):
             tablefmt='simple')
         message = (f"<b>{min(trades['trades_count'], nrecent)} recent trades</b>:\n"
                    + (f"<pre>{trades_tab}</pre>" if trades['trades_count'] > 0 else ''))
-        self._send_msg(message, parse_mode=ParseMode.HTML)
+        await self._send_msg(message, parse_mode=ParseMode.HTML)
 
     @authorized_only
-    def _delete_trade(self, update: Update, context: CallbackContext) -> None:
+    async def _delete_trade(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /delete <id>.
         Delete the given trade
@@ -1184,13 +1237,13 @@ class Telegram(RPCHandler):
             raise RPCException("Trade-id not set.")
         trade_id = int(context.args[0])
         msg = self._rpc._rpc_delete(trade_id)
-        self._send_msg(
+        await self._send_msg(
             f"`{msg['result_msg']}`\n"
             'Please make sure to take care of this asset on the exchange manually.'
         )
 
     @authorized_only
-    def _cancel_open_order(self, update: Update, context: CallbackContext) -> None:
+    async def _cancel_open_order(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /cancel_open_order <id>.
         Cancel open order for tradeid
@@ -1202,10 +1255,10 @@ class Telegram(RPCHandler):
             raise RPCException("Trade-id not set.")
         trade_id = int(context.args[0])
         self._rpc._rpc_cancel_open_order(trade_id)
-        self._send_msg('Open order canceled.')
+        await self._send_msg('Open order canceled.')
 
     @authorized_only
-    def _performance(self, update: Update, context: CallbackContext) -> None:
+    async def _performance(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /performance.
         Shows a performance statistic from finished trades
@@ -1223,17 +1276,17 @@ class Telegram(RPCHandler):
                 f"({trade['count']})</code>\n")
 
             if len(output + stat_line) >= MAX_MESSAGE_LENGTH:
-                self._send_msg(output, parse_mode=ParseMode.HTML)
+                await self._send_msg(output, parse_mode=ParseMode.HTML)
                 output = stat_line
             else:
                 output += stat_line
 
-        self._send_msg(output, parse_mode=ParseMode.HTML,
-                       reload_able=True, callback_path="update_performance",
-                       query=update.callback_query)
+        await self._send_msg(output, parse_mode=ParseMode.HTML,
+                             reload_able=True, callback_path="update_performance",
+                             query=update.callback_query)
 
     @authorized_only
-    def _enter_tag_performance(self, update: Update, context: CallbackContext) -> None:
+    async def _enter_tag_performance(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /buys PAIR .
         Shows a performance statistic from finished trades
@@ -1255,17 +1308,17 @@ class Telegram(RPCHandler):
                 f"({trade['count']})</code>\n")
 
             if len(output + stat_line) >= MAX_MESSAGE_LENGTH:
-                self._send_msg(output, parse_mode=ParseMode.HTML)
+                await self._send_msg(output, parse_mode=ParseMode.HTML)
                 output = stat_line
             else:
                 output += stat_line
 
-        self._send_msg(output, parse_mode=ParseMode.HTML,
-                       reload_able=True, callback_path="update_enter_tag_performance",
-                       query=update.callback_query)
+        await self._send_msg(output, parse_mode=ParseMode.HTML,
+                             reload_able=True, callback_path="update_enter_tag_performance",
+                             query=update.callback_query)
 
     @authorized_only
-    def _exit_reason_performance(self, update: Update, context: CallbackContext) -> None:
+    async def _exit_reason_performance(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /sells.
         Shows a performance statistic from finished trades
@@ -1287,17 +1340,17 @@ class Telegram(RPCHandler):
                 f"({trade['count']})</code>\n")
 
             if len(output + stat_line) >= MAX_MESSAGE_LENGTH:
-                self._send_msg(output, parse_mode=ParseMode.HTML)
+                await self._send_msg(output, parse_mode=ParseMode.HTML)
                 output = stat_line
             else:
                 output += stat_line
 
-        self._send_msg(output, parse_mode=ParseMode.HTML,
-                       reload_able=True, callback_path="update_exit_reason_performance",
-                       query=update.callback_query)
+        await self._send_msg(output, parse_mode=ParseMode.HTML,
+                             reload_able=True, callback_path="update_exit_reason_performance",
+                             query=update.callback_query)
 
     @authorized_only
-    def _mix_tag_performance(self, update: Update, context: CallbackContext) -> None:
+    async def _mix_tag_performance(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /mix_tags.
         Shows a performance statistic from finished trades
@@ -1319,17 +1372,17 @@ class Telegram(RPCHandler):
                 f"({trade['count']})</code>\n")
 
             if len(output + stat_line) >= MAX_MESSAGE_LENGTH:
-                self._send_msg(output, parse_mode=ParseMode.HTML)
+                await self._send_msg(output, parse_mode=ParseMode.HTML)
                 output = stat_line
             else:
                 output += stat_line
 
-        self._send_msg(output, parse_mode=ParseMode.HTML,
-                       reload_able=True, callback_path="update_mix_tag_performance",
-                       query=update.callback_query)
+        await self._send_msg(output, parse_mode=ParseMode.HTML,
+                             reload_able=True, callback_path="update_mix_tag_performance",
+                             query=update.callback_query)
 
     @authorized_only
-    def _count(self, update: Update, context: CallbackContext) -> None:
+    async def _count(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /count.
         Returns the number of trades running
@@ -1343,19 +1396,19 @@ class Telegram(RPCHandler):
                            tablefmt='simple')
         message = f"<pre>{message}</pre>"
         logger.debug(message)
-        self._send_msg(message, parse_mode=ParseMode.HTML,
-                       reload_able=True, callback_path="update_count",
-                       query=update.callback_query)
+        await self._send_msg(message, parse_mode=ParseMode.HTML,
+                             reload_able=True, callback_path="update_count",
+                             query=update.callback_query)
 
     @authorized_only
-    def _locks(self, update: Update, context: CallbackContext) -> None:
+    async def _locks(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /locks.
         Returns the currently active locks
         """
         rpc_locks = self._rpc._rpc_locks()
         if not rpc_locks['locks']:
-            self._send_msg('No active locks.', parse_mode=ParseMode.HTML)
+            await self._send_msg('No active locks.', parse_mode=ParseMode.HTML)
 
         for locks in chunks(rpc_locks['locks'], 25):
             message = tabulate([[
@@ -1367,10 +1420,10 @@ class Telegram(RPCHandler):
                 tablefmt='simple')
             message = f"<pre>{escape(message)}</pre>"
             logger.debug(message)
-            self._send_msg(message, parse_mode=ParseMode.HTML)
+            await self._send_msg(message, parse_mode=ParseMode.HTML)
 
     @authorized_only
-    def _delete_locks(self, update: Update, context: CallbackContext) -> None:
+    async def _delete_locks(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /delete_locks.
         Returns the currently active locks
@@ -1385,10 +1438,10 @@ class Telegram(RPCHandler):
                 pair = arg
 
         self._rpc._rpc_delete_lock(lockid=lockid, pair=pair)
-        self._locks(update, context)
+        await self._locks(update, context)
 
     @authorized_only
-    def _whitelist(self, update: Update, context: CallbackContext) -> None:
+    async def _whitelist(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /whitelist
         Shows the currently active whitelist
@@ -1405,39 +1458,39 @@ class Telegram(RPCHandler):
         message += f"`{', '.join(whitelist['whitelist'])}`"
 
         logger.debug(message)
-        self._send_msg(message)
+        await self._send_msg(message)
 
     @authorized_only
-    def _blacklist(self, update: Update, context: CallbackContext) -> None:
+    async def _blacklist(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /blacklist
         Shows the currently active blacklist
         """
-        self.send_blacklist_msg(self._rpc._rpc_blacklist(context.args))
+        await self.send_blacklist_msg(self._rpc._rpc_blacklist(context.args))
 
-    def send_blacklist_msg(self, blacklist: Dict):
+    async def send_blacklist_msg(self, blacklist: Dict):
         errmsgs = []
         for pair, error in blacklist['errors'].items():
             errmsgs.append(f"Error: {error['error_msg']}")
         if errmsgs:
-            self._send_msg('\n'.join(errmsgs))
+            await self._send_msg('\n'.join(errmsgs))
 
         message = f"Blacklist contains {blacklist['length']} pairs\n"
         message += f"`{', '.join(blacklist['blacklist'])}`"
 
         logger.debug(message)
-        self._send_msg(message)
+        await self._send_msg(message)
 
     @authorized_only
-    def _blacklist_delete(self, update: Update, context: CallbackContext) -> None:
+    async def _blacklist_delete(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /bl_delete
         Deletes pair(s) from current blacklist
         """
-        self.send_blacklist_msg(self._rpc._rpc_blacklist_delete(context.args or []))
+        await self.send_blacklist_msg(self._rpc._rpc_blacklist_delete(context.args or []))
 
     @authorized_only
-    def _logs(self, update: Update, context: CallbackContext) -> None:
+    async def _logs(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /logs
         Shows the latest logs
@@ -1456,17 +1509,17 @@ class Telegram(RPCHandler):
                                       escape_markdown(logrec[4], version=2))
             if len(msgs + msg) + 10 >= MAX_MESSAGE_LENGTH:
                 # Send message immediately if it would become too long
-                self._send_msg(msgs, parse_mode=ParseMode.MARKDOWN_V2)
+                await self._send_msg(msgs, parse_mode=ParseMode.MARKDOWN_V2)
                 msgs = msg + '\n'
             else:
                 # Append message to messages to send
                 msgs += msg + '\n'
 
         if msgs:
-            self._send_msg(msgs, parse_mode=ParseMode.MARKDOWN_V2)
+            await self._send_msg(msgs, parse_mode=ParseMode.MARKDOWN_V2)
 
     @authorized_only
-    def _edge(self, update: Update, context: CallbackContext) -> None:
+    async def _edge(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /edge
         Shows information related to Edge
@@ -1474,17 +1527,17 @@ class Telegram(RPCHandler):
         edge_pairs = self._rpc._rpc_edge()
         if not edge_pairs:
             message = '<b>Edge only validated following pairs:</b>'
-            self._send_msg(message, parse_mode=ParseMode.HTML)
+            await self._send_msg(message, parse_mode=ParseMode.HTML)
 
         for chunk in chunks(edge_pairs, 25):
             edge_pairs_tab = tabulate(chunk, headers='keys', tablefmt='simple')
             message = (f'<b>Edge only validated following pairs:</b>\n'
                        f'<pre>{edge_pairs_tab}</pre>')
 
-            self._send_msg(message, parse_mode=ParseMode.HTML)
+            await self._send_msg(message, parse_mode=ParseMode.HTML)
 
     @authorized_only
-    def _help(self, update: Update, context: CallbackContext) -> None:
+    async def _help(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /help.
         Show commands of the bot
@@ -1511,6 +1564,7 @@ class Telegram(RPCHandler):
             "*/fx <trade_id>|all:* `Alias to /forceexit`\n"
             f"{force_enter_text if self._config.get('force_entry_enable', False) else ''}"
             "*/delete <trade_id>:* `Instantly delete the given trade in the database`\n"
+            "*/reload_trade <trade_id>:* `Relade trade from exchange Orders`\n"
             "*/cancel_open_order <trade_id>:* `Cancels open orders for trade. "
             "Only valid when the trade has open orders.`\n"
             "*/coo <trade_id>|all:* `Alias to /cancel_open_order`\n"
@@ -1528,7 +1582,8 @@ class Telegram(RPCHandler):
             "------------\n"
             "*/show_config:* `Show running configuration` \n"
             "*/locks:* `Show currently locked pairs`\n"
-            "*/balance:* `Show account balance per currency`\n"
+            "*/balance:* `Show bot managed balance per currency`\n"
+            "*/balance total:* `Show account balance per currency`\n"
             "*/logs [limit]:* `Show latest logs - defaults to 10` \n"
             "*/count:* `Show number of active trades compared to allowed number of trades`\n"
             "*/edge:* `Shows validated pairs by Edge if it is enabled` \n"
@@ -1561,20 +1616,20 @@ class Telegram(RPCHandler):
             "*/version:* `Show version`"
             )
 
-        self._send_msg(message, parse_mode=ParseMode.MARKDOWN)
+        await self._send_msg(message, parse_mode=ParseMode.MARKDOWN)
 
     @authorized_only
-    def _health(self, update: Update, context: CallbackContext) -> None:
+    async def _health(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /health
         Shows the last process timestamp
         """
         health = self._rpc.health()
         message = f"Last process: `{health['last_process_loc']}`"
-        self._send_msg(message)
+        await self._send_msg(message)
 
     @authorized_only
-    def _version(self, update: Update, context: CallbackContext) -> None:
+    async def _version(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /version.
         Show version information
@@ -1585,12 +1640,12 @@ class Telegram(RPCHandler):
         strategy_version = self._rpc._freqtrade.strategy.version()
         version_string = f'*Version:* `{__version__}`'
         if strategy_version is not None:
-            version_string += f', *Strategy version: * `{strategy_version}`'
+            version_string += f'\n*Strategy version: * `{strategy_version}`'
 
-        self._send_msg(version_string)
+        await self._send_msg(version_string)
 
     @authorized_only
-    def _show_config(self, update: Update, context: CallbackContext) -> None:
+    async def _show_config(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /show_config.
         Show config information information
@@ -1619,7 +1674,7 @@ class Telegram(RPCHandler):
         else:
             pa_info = "*Position adjustment:* Off\n"
 
-        self._send_msg(
+        await self._send_msg(
             f"*Mode:* `{'Dry-run' if val['dry_run'] else 'Live'}`\n"
             f"*Exchange:* `{val['exchange']}`\n"
             f"*Market: * `{val['trading_mode']}`\n"
@@ -1635,8 +1690,8 @@ class Telegram(RPCHandler):
             f"*Current state:* `{val['state']}`"
         )
 
-    def _update_msg(self, query: CallbackQuery, msg: str, callback_path: str = "",
-                    reload_able: bool = False, parse_mode: str = ParseMode.MARKDOWN) -> None:
+    async def _update_msg(self, query: CallbackQuery, msg: str, callback_path: str = "",
+                          reload_able: bool = False, parse_mode: str = ParseMode.MARKDOWN) -> None:
         if reload_able:
             reply_markup = InlineKeyboardMarkup([
                 [InlineKeyboardButton("Refresh", callback_data=callback_path)],
@@ -1650,7 +1705,7 @@ class Telegram(RPCHandler):
         message_id = query.message.message_id
 
         try:
-            self._updater.bot.edit_message_text(
+            await self._app.bot.edit_message_text(
                 chat_id=chat_id,
                 message_id=message_id,
                 text=msg,
@@ -1665,12 +1720,12 @@ class Telegram(RPCHandler):
         except TelegramError as telegram_err:
             logger.warning('TelegramError: %s! Giving up on that message.', telegram_err.message)
 
-    def _send_msg(self, msg: str, parse_mode: str = ParseMode.MARKDOWN,
-                  disable_notification: bool = False,
-                  keyboard: Optional[List[List[InlineKeyboardButton]]] = None,
-                  callback_path: str = "",
-                  reload_able: bool = False,
-                  query: Optional[CallbackQuery] = None) -> None:
+    async def _send_msg(self, msg: str, parse_mode: str = ParseMode.MARKDOWN,
+                        disable_notification: bool = False,
+                        keyboard: Optional[List[List[InlineKeyboardButton]]] = None,
+                        callback_path: str = "",
+                        reload_able: bool = False,
+                        query: Optional[CallbackQuery] = None) -> None:
         """
         Send given markdown message
         :param msg: message
@@ -1680,20 +1735,20 @@ class Telegram(RPCHandler):
         """
         reply_markup: Union[InlineKeyboardMarkup, ReplyKeyboardMarkup]
         if query:
-            self._update_msg(query=query, msg=msg, parse_mode=parse_mode,
-                             callback_path=callback_path, reload_able=reload_able)
+            await self._update_msg(query=query, msg=msg, parse_mode=parse_mode,
+                                   callback_path=callback_path, reload_able=reload_able)
             return
         if reload_able and self._config['telegram'].get('reload', True):
             reply_markup = InlineKeyboardMarkup([
                 [InlineKeyboardButton("Refresh", callback_data=callback_path)]])
         else:
             if keyboard is not None:
-                reply_markup = InlineKeyboardMarkup(keyboard, resize_keyboard=True)
+                reply_markup = InlineKeyboardMarkup(keyboard)
             else:
                 reply_markup = ReplyKeyboardMarkup(self._keyboard, resize_keyboard=True)
         try:
             try:
-                self._updater.bot.send_message(
+                await self._app.bot.send_message(
                     self._config['telegram']['chat_id'],
                     text=msg,
                     parse_mode=parse_mode,
@@ -1707,7 +1762,7 @@ class Telegram(RPCHandler):
                     'Telegram NetworkError: %s! Trying one more time.',
                     network_err.message
                 )
-                self._updater.bot.send_message(
+                await self._app.bot.send_message(
                     self._config['telegram']['chat_id'],
                     text=msg,
                     parse_mode=parse_mode,
@@ -1721,7 +1776,7 @@ class Telegram(RPCHandler):
             )
 
     @authorized_only
-    def _changemarketdir(self, update: Update, context: CallbackContext) -> None:
+    async def _changemarketdir(self, update: Update, context: CallbackContext) -> None:
         """
         Handler for /marketdir.
         Updates the bot's market_direction
@@ -1744,14 +1799,14 @@ class Telegram(RPCHandler):
 
             if new_market_dir is not None:
                 self._rpc._update_market_direction(new_market_dir)
-                self._send_msg("Successfully updated market direction"
-                               f" from *{old_market_dir}* to *{new_market_dir}*.")
+                await self._send_msg("Successfully updated market direction"
+                                     f" from *{old_market_dir}* to *{new_market_dir}*.")
             else:
                 raise RPCException("Invalid market direction provided. \n"
                                    "Valid market directions: *long, short, even, none*")
         elif context.args is not None and len(context.args) == 0:
             old_market_dir = self._rpc._get_market_direction()
-            self._send_msg(f"Currently set market direction: *{old_market_dir}*")
+            await self._send_msg(f"Currently set market direction: *{old_market_dir}*")
         else:
             raise RPCException("Invalid usage of command /marketdir. \n"
                                "Usage: */marketdir [short |  long | even | none]*")
diff --git a/freqtrade/rpc/webhook.py b/freqtrade/rpc/webhook.py
index 14b881126..80690ec0c 100644
--- a/freqtrade/rpc/webhook.py
+++ b/freqtrade/rpc/webhook.py
@@ -44,8 +44,11 @@ class Webhook(RPCHandler):
 
     def _get_value_dict(self, msg: RPCSendMsg) -> Optional[Dict[str, Any]]:
         whconfig = self._config['webhook']
+        if msg['type'].value in whconfig:
+            # Explicit types should have priority
+            valuedict = whconfig.get(msg['type'].value)
         # Deprecated 2022.10 - only keep generic method.
-        if msg['type'] in [RPCMessageType.ENTRY]:
+        elif msg['type'] in [RPCMessageType.ENTRY]:
             valuedict = whconfig.get('webhookentry')
         elif msg['type'] in [RPCMessageType.ENTRY_CANCEL]:
             valuedict = whconfig.get('webhookentrycancel')
@@ -62,9 +65,6 @@ class Webhook(RPCHandler):
                              RPCMessageType.EXCEPTION,
                              RPCMessageType.WARNING):
             valuedict = whconfig.get('webhookstatus')
-        elif msg['type'].value in whconfig:
-            # Allow all types ...
-            valuedict = whconfig.get(msg['type'].value)
         elif msg['type'] in (
                 RPCMessageType.PROTECTION_TRIGGER,
                 RPCMessageType.PROTECTION_TRIGGER_GLOBAL,
diff --git a/freqtrade/strategy/interface.py b/freqtrade/strategy/interface.py
index 7adb7a154..382f38c9a 100644
--- a/freqtrade/strategy/interface.py
+++ b/freqtrade/strategy/interface.py
@@ -7,7 +7,6 @@ from abc import ABC, abstractmethod
 from datetime import datetime, timedelta, timezone
 from typing import Dict, List, Optional, Tuple, Union
 
-import arrow
 from pandas import DataFrame
 
 from freqtrade.constants import CUSTOM_TAG_MAX_LENGTH, Config, IntOrInf, ListPairsWithTimeframes
@@ -23,6 +22,7 @@ from freqtrade.strategy.informative_decorator import (InformativeData, PopulateI
                                                       _create_and_merge_informative_pair,
                                                       _format_pair_name)
 from freqtrade.strategy.strategy_wrapper import strategy_safe_wrapper
+from freqtrade.util import dt_now
 from freqtrade.wallets import Wallets
 
 
@@ -938,7 +938,7 @@ class IStrategy(ABC, HyperStrategyMixin):
         pair: str,
         timeframe: str,
         dataframe: DataFrame,
-    ) -> Tuple[Optional[DataFrame], Optional[arrow.Arrow]]:
+    ) -> Tuple[Optional[DataFrame], Optional[datetime]]:
         """
         Calculates current signal based based on the entry order or exit order
         columns of the dataframe.
@@ -954,16 +954,16 @@ class IStrategy(ABC, HyperStrategyMixin):
 
         latest_date = dataframe['date'].max()
         latest = dataframe.loc[dataframe['date'] == latest_date].iloc[-1]
-        # Explicitly convert to arrow object to ensure the below comparison does not fail
-        latest_date = arrow.get(latest_date)
+        # Explicitly convert to datetime object to ensure the below comparison does not fail
+        latest_date = latest_date.to_pydatetime()
 
         # Check if dataframe is out of date
         timeframe_minutes = timeframe_to_minutes(timeframe)
         offset = self.config.get('exchange', {}).get('outdated_offset', 5)
-        if latest_date < (arrow.utcnow().shift(minutes=-(timeframe_minutes * 2 + offset))):
+        if latest_date < (dt_now() - timedelta(minutes=timeframe_minutes * 2 + offset)):
             logger.warning(
                 'Outdated history for pair %s. Last tick is %s minutes old',
-                pair, int((arrow.utcnow() - latest_date).total_seconds() // 60)
+                pair, int((dt_now() - latest_date).total_seconds() // 60)
             )
             return None, None
         return latest, latest_date
@@ -1046,8 +1046,8 @@ class IStrategy(ABC, HyperStrategyMixin):
         timeframe_seconds = timeframe_to_seconds(timeframe)
 
         if self.ignore_expired_candle(
-            latest_date=latest_date.datetime,
-            current_time=datetime.now(timezone.utc),
+            latest_date=latest_date,
+            current_time=dt_now(),
             timeframe_seconds=timeframe_seconds,
             enter=bool(enter_signal)
         ):
diff --git a/freqtrade/templates/FreqaiExampleStrategy.py b/freqtrade/templates/FreqaiExampleStrategy.py
index 493ea17f3..347efdda0 100644
--- a/freqtrade/templates/FreqaiExampleStrategy.py
+++ b/freqtrade/templates/FreqaiExampleStrategy.py
@@ -15,12 +15,15 @@ logger = logging.getLogger(__name__)
 class FreqaiExampleStrategy(IStrategy):
     """
     Example strategy showing how the user connects their own
-    IFreqaiModel to the strategy. Namely, the user uses:
-    self.freqai.start(dataframe, metadata)
+    IFreqaiModel to the strategy.
 
-    to make predictions on their data. feature_engineering_*() automatically
-    generate the variety of features indicated by the user in the
-    canonical freqtrade configuration file under config['freqai'].
+    Warning! This is a showcase of functionality,
+    which means that it is designed to show various functions of FreqAI
+    and it runs on all computers. We use this showcase to help users
+    understand how to build a strategy, and we use it as a benchmark
+    to help debug possible problems.
+
+    This means this is *not* meant to be run live in production.
     """
 
     minimal_roi = {"0": 0.1, "240": -1}
diff --git a/freqtrade/util/__init__.py b/freqtrade/util/__init__.py
index 3c3c034c1..bed65a54b 100644
--- a/freqtrade/util/__init__.py
+++ b/freqtrade/util/__init__.py
@@ -1,2 +1,17 @@
-from freqtrade.util.ft_precise import FtPrecise  # noqa: F401
-from freqtrade.util.periodic_cache import PeriodicCache  # noqa: F401
+from freqtrade.util.datetime_helpers import (dt_floor_day, dt_from_ts, dt_humanize, dt_now, dt_ts,
+                                             dt_utc, shorten_date)
+from freqtrade.util.ft_precise import FtPrecise
+from freqtrade.util.periodic_cache import PeriodicCache
+
+
+__all__ = [
+    'dt_floor_day',
+    'dt_from_ts',
+    'dt_now',
+    'dt_ts',
+    'dt_utc',
+    'dt_humanize',
+    'shorten_date',
+    'FtPrecise',
+    'PeriodicCache',
+]
diff --git a/freqtrade/util/datetime_helpers.py b/freqtrade/util/datetime_helpers.py
new file mode 100644
index 000000000..39d134e11
--- /dev/null
+++ b/freqtrade/util/datetime_helpers.py
@@ -0,0 +1,63 @@
+import re
+from datetime import datetime, timezone
+from typing import Optional
+
+import arrow
+
+
+def dt_now() -> datetime:
+    """Return the current datetime in UTC."""
+    return datetime.now(timezone.utc)
+
+
+def dt_utc(year: int, month: int, day: int, hour: int = 0, minute: int = 0, second: int = 0,
+           microsecond: int = 0) -> datetime:
+    """Return a datetime in UTC."""
+    return datetime(year, month, day, hour, minute, second, microsecond, tzinfo=timezone.utc)
+
+
+def dt_ts(dt: Optional[datetime] = None) -> int:
+    """
+    Return dt in ms as a timestamp in UTC.
+    If dt is None, return the current datetime in UTC.
+    """
+    if dt:
+        return int(dt.timestamp() * 1000)
+    return int(dt_now().timestamp() * 1000)
+
+
+def dt_floor_day(dt: datetime) -> datetime:
+    """Return the floor of the day for the given datetime."""
+    return dt.replace(hour=0, minute=0, second=0, microsecond=0)
+
+
+def dt_from_ts(timestamp: float) -> datetime:
+    """
+    Return a datetime from a timestamp.
+    :param timestamp: timestamp in seconds or milliseconds
+    """
+    if timestamp > 1e10:
+        # Timezone in ms - convert to seconds
+        timestamp /= 1000
+    return datetime.fromtimestamp(timestamp, tz=timezone.utc)
+
+
+def shorten_date(_date: str) -> str:
+    """
+    Trim the date so it fits on small screens
+    """
+    new_date = re.sub('seconds?', 'sec', _date)
+    new_date = re.sub('minutes?', 'min', new_date)
+    new_date = re.sub('hours?', 'h', new_date)
+    new_date = re.sub('days?', 'd', new_date)
+    new_date = re.sub('^an?', '1', new_date)
+    return new_date
+
+
+def dt_humanize(dt: datetime, **kwargs) -> str:
+    """
+    Return a humanized string for the given datetime.
+    :param dt: datetime to humanize
+    :param kwargs: kwargs to pass to arrow's humanize()
+    """
+    return arrow.get(dt).humanize(**kwargs)
diff --git a/freqtrade/wallets.py b/freqtrade/wallets.py
index 6f86398f3..da64515a4 100644
--- a/freqtrade/wallets.py
+++ b/freqtrade/wallets.py
@@ -3,16 +3,16 @@
 
 import logging
 from copy import deepcopy
+from datetime import datetime, timedelta
 from typing import Dict, NamedTuple, Optional
 
-import arrow
-
 from freqtrade.constants import UNLIMITED_STAKE_AMOUNT, Config
 from freqtrade.enums import RunMode, TradingMode
 from freqtrade.exceptions import DependencyException
 from freqtrade.exchange import Exchange
 from freqtrade.misc import safe_value_fallback
 from freqtrade.persistence import LocalTrade, Trade
+from freqtrade.util.datetime_helpers import dt_now
 
 
 logger = logging.getLogger(__name__)
@@ -43,7 +43,7 @@ class Wallets:
         self._wallets: Dict[str, Wallet] = {}
         self._positions: Dict[str, PositionWallet] = {}
         self.start_cap = config['dry_run_wallet']
-        self._last_wallet_refresh = 0
+        self._last_wallet_refresh: Optional[datetime] = None
         self.update()
 
     def get_free(self, currency: str) -> float:
@@ -166,14 +166,19 @@ class Wallets:
         for trading operations, the latest balance is needed.
         :param require_update: Allow skipping an update if balances were recently refreshed
         """
-        if (require_update or (self._last_wallet_refresh + 3600 < arrow.utcnow().int_timestamp)):
+        now = dt_now()
+        if (
+            require_update
+            or self._last_wallet_refresh is None
+            or (self._last_wallet_refresh + timedelta(seconds=3600) < now)
+        ):
             if (not self._config['dry_run'] or self._config.get('runmode') == RunMode.LIVE):
                 self._update_live()
             else:
                 self._update_dry()
             if self._log:
                 logger.info('Wallets synced.')
-            self._last_wallet_refresh = arrow.utcnow().int_timestamp
+            self._last_wallet_refresh = dt_now()
 
     def get_all_balances(self) -> Dict[str, Wallet]:
         return self._wallets
@@ -181,6 +186,35 @@ class Wallets:
     def get_all_positions(self) -> Dict[str, PositionWallet]:
         return self._positions
 
+    def _check_exit_amount(self, trade: Trade) -> bool:
+        if trade.trading_mode != TradingMode.FUTURES:
+            # Slightly higher offset than in safe_exit_amount.
+            wallet_amount: float = self.get_total(trade.safe_base_currency) * (2 - 0.981)
+        else:
+            # wallet_amount: float = self.wallets.get_free(trade.safe_base_currency)
+            position = self._positions.get(trade.pair)
+            if position is None:
+                # We don't own anything :O
+                return False
+            wallet_amount = position.position
+
+        if wallet_amount >= trade.amount:
+            return True
+        return False
+
+    def check_exit_amount(self, trade: Trade) -> bool:
+        """
+        Checks if the exit amount is available in the wallet.
+        :param trade: Trade to check
+        :return: True if the exit amount is available, False otherwise
+        """
+        if not self._check_exit_amount(trade):
+            # Update wallets just to make sure
+            self.update()
+            return self._check_exit_amount(trade)
+
+        return True
+
     def get_starting_balance(self) -> float:
         """
         Retrieves starting balance - based on either available capital,
diff --git a/pyproject.toml b/pyproject.toml
index 28de6a1d8..17f91c7b2 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,5 +1,5 @@
 [build-system]
-requires = ["setuptools >= 46.4.0", "wheel"]
+requires = ["setuptools >= 64.0.0", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [tool.black]
diff --git a/requirements-dev.txt b/requirements-dev.txt
index cd4c96eea..cc3463174 100644
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -7,9 +7,9 @@
 -r docs/requirements-docs.txt
 
 coveralls==3.3.1
-ruff==0.0.262
-mypy==1.2.0
-pre-commit==3.2.2
+ruff==0.0.269
+mypy==1.3.0
+pre-commit==3.3.2
 pytest==7.3.1
 pytest-asyncio==0.21.0
 pytest-cov==4.0.0
@@ -18,15 +18,13 @@ pytest-random-order==1.1.0
 isort==5.12.0
 # For datetime mocking
 time-machine==2.9.0
-# fastapi testing
-httpx==0.24.0
 
 # Convert jupyter notebooks to markdown documents
-nbconvert==7.3.1
+nbconvert==7.4.0
 
 # mypy types
 types-cachetools==5.3.0.5
 types-filelock==3.2.7
-types-requests==2.28.11.17
+types-requests==2.30.0.0
 types-tabulate==0.9.0.2
-types-python-dateutil==2.8.19.12
+types-python-dateutil==2.8.19.13
diff --git a/requirements-freqai-rl.txt b/requirements-freqai-rl.txt
index f4e1e557b..de48a1da4 100644
--- a/requirements-freqai-rl.txt
+++ b/requirements-freqai-rl.txt
@@ -2,11 +2,10 @@
 -r requirements-freqai.txt
 
 # Required for freqai-rl
-torch==1.13.1; python_version < '3.11'
-stable-baselines3==1.7.0; python_version < '3.11'
-sb3-contrib==1.7.0; python_version < '3.11'
-# Gym is forced to this version by stable-baselines3.
-setuptools==65.5.1 # Should be removed when gym is fixed.
-gym==0.21; python_version < '3.11'
+torch==2.0.1
+#until these branches will be released we can use this
+gymnasium==0.28.1
+stable_baselines3==2.0.0a10
+sb3_contrib>=2.0.0a9
 # Progress bar for stable-baselines3 and sb3-contrib
-tqdm==4.65.0; python_version < '3.11'
+tqdm==4.65.0
diff --git a/requirements-freqai.txt b/requirements-freqai.txt
index 51396ab91..ad069ade2 100644
--- a/requirements-freqai.txt
+++ b/requirements-freqai.txt
@@ -5,7 +5,8 @@
 # Required for freqai
 scikit-learn==1.1.3
 joblib==1.2.0
-catboost==1.1.1; platform_machine != 'aarch64' and 'arm' not in platform_machine and python_version < '3.11'
+catboost==1.1.1; sys_platform == 'darwin' and python_version < '3.9'
+catboost==1.2; 'arm' not in platform_machine and (sys_platform != 'darwin' or python_version >= '3.9')
 lightgbm==3.3.5
 xgboost==1.7.5
-tensorboard==2.12.2
+tensorboard==2.13.0
diff --git a/requirements.txt b/requirements.txt
index 9d51852fc..cff54ca1c 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,16 +1,19 @@
 numpy==1.24.3
-pandas==1.5.3
+pandas==2.0.1
 pandas-ta==0.3.14b
 
-ccxt==3.0.75
-cryptography==40.0.2
+ccxt==3.1.5
+cryptography==40.0.2; platform_machine != 'armv7l'
+cryptography==40.0.1; platform_machine == 'armv7l'
 aiohttp==3.8.4
-SQLAlchemy==2.0.10
-python-telegram-bot==13.15
+SQLAlchemy==2.0.15
+python-telegram-bot==20.3
+# can't be hard-pinned due to telegram-bot pinning httpx with ~
+httpx>=0.23.3
 arrow==1.2.3
-cachetools==4.2.2
-requests==2.28.2
-urllib3==1.26.15
+cachetools==5.3.0
+requests==2.31.0
+urllib3==2.0.2
 jsonschema==4.17.3
 TA-Lib==0.4.26
 technical==1.4.0
@@ -20,8 +23,8 @@ jinja2==3.1.2
 tables==3.8.0
 blosc==1.11.1
 joblib==1.2.0
-rich==13.3.4
-pyarrow==11.0.0; platform_machine != 'armv7l'
+rich==13.3.5
+pyarrow==12.0.0; platform_machine != 'armv7l'
 
 # find first, C search in arrays
 py_find_1st==1.1.5
@@ -29,16 +32,16 @@ py_find_1st==1.1.5
 # Load ticker files 30% faster
 python-rapidjson==1.10
 # Properly format api responses
-orjson==3.8.10
+orjson==3.8.12
 
 # Notify systemd
 sdnotify==0.3.2
 
 # API Server
-fastapi==0.95.1
+fastapi==0.95.2
 pydantic==1.10.7
-uvicorn==0.21.1
-pyjwt==2.6.0
+uvicorn==0.22.0
+pyjwt==2.7.0
 aiofiles==23.1.0
 psutil==5.9.5
 
@@ -54,7 +57,8 @@ python-dateutil==2.8.2
 schedule==1.2.0
 
 #WS Messages
-websockets==11.0.2
+websockets==11.0.3
 janus==1.0.0
 
 ast-comments==1.0.1
+packaging==23.1
diff --git a/scripts/rest_client.py b/scripts/rest_client.py
index 196542780..0772af269 100755
--- a/scripts/rest_client.py
+++ b/scripts/rest_client.py
@@ -279,8 +279,9 @@ class FtRestClient():
         """
         data = {"pair": pair,
                 "side": side,
-                "price": price,
                 }
+        if price:
+            data['price'] = price
         return self._post("forceenter", data=data)
 
     def forceexit(self, tradeid, ordertype=None, amount=None):
@@ -348,12 +349,13 @@ class FtRestClient():
             params['limit'] = limit
         return self._get("pair_candles", params=params)
 
-    def pair_history(self, pair, timeframe, strategy, timerange=None):
+    def pair_history(self, pair, timeframe, strategy, timerange=None, freqaimodel=None):
         """Return historic, analyzed dataframe
 
         :param pair: Pair to get data for
         :param timeframe: Only pairs with this timeframe available.
         :param strategy: Strategy to analyze and get values for
+        :param freqaimodel: FreqAI model to use for analysis
         :param timerange: Timerange to get data for (same format than --timerange endpoints)
         :return: json object
         """
@@ -361,6 +363,7 @@ class FtRestClient():
             "pair": pair,
             "timeframe": timeframe,
             "strategy": strategy,
+            "freqaimodel": freqaimodel,
             "timerange": timerange if timerange else '',
         })
 
diff --git a/setup.py b/setup.py
index 048dc066d..f8b8b515c 100644
--- a/setup.py
+++ b/setup.py
@@ -12,16 +12,19 @@ hyperopt = [
 
 freqai = [
     'scikit-learn',
+    'joblib',
     'catboost; platform_machine != "aarch64"',
     'lightgbm',
-    'xgboost'
+    'xgboost',
+    'tensorboard'
 ]
 
 freqai_rl = [
     'torch',
+    'gymnasium',
     'stable-baselines3',
-    'gym==0.21',
-    'sb3-contrib'
+    'sb3-contrib',
+    'tqdm'
 ]
 
 hdf5 = [
@@ -32,11 +35,20 @@ hdf5 = [
 develop = [
     'coveralls',
     'mypy',
+    'ruff',
+    'pre-commit',
     'pytest',
     'pytest-asyncio',
     'pytest-cov',
     'pytest-mock',
     'pytest-random-order',
+    'isort',
+    'time-machine',
+    'types-cachetools',
+    'types-filelock',
+    'types-requests',
+    'types-tabulate',
+    'types-python-dateutil'
 ]
 
 jupyter = [
@@ -57,10 +69,10 @@ setup(
     ],
     install_requires=[
         # from requirements.txt
-        'ccxt>=2.6.26',
+        'ccxt>=3.0.0',
         'SQLAlchemy>=2.0.6',
-        'python-telegram-bot>=13.4',
-        'arrow>=0.17.0',
+        'python-telegram-bot>=20.1',
+        'arrow>=1.0.0',
         'cachetools',
         'requests',
         'urllib3',
@@ -91,7 +103,13 @@ setup(
         'aiofiles',
         'schedule',
         'websockets',
-        'janus'
+        'janus',
+        'ast-comments',
+        'aiohttp',
+        'cryptography',
+        'httpx',
+        'python-dateutil',
+        'packaging',
     ],
     extras_require={
         'dev': all_extra,
diff --git a/setup.sh b/setup.sh
index d46569a53..84f804021 100755
--- a/setup.sh
+++ b/setup.sh
@@ -25,7 +25,7 @@ function check_installed_python() {
         exit 2
     fi
 
-    for v in 10 9 8
+    for v in 11 10 9 8
     do
         PYTHON="python3.${v}"
         which $PYTHON
@@ -49,8 +49,7 @@ function updateenv() {
     source .env/bin/activate
     SYS_ARCH=$(uname -m)
     echo "pip install in-progress. Please wait..."
-    # Setuptools 65.5.0 is the last version that can install gym==0.21.0
-    ${PYTHON} -m pip install --upgrade pip==23.0.1 wheel==0.38.4 setuptools==65.5.1
+    ${PYTHON} -m pip install --upgrade pip wheel setuptools
     REQUIREMENTS_HYPEROPT=""
     REQUIREMENTS_PLOT=""
     REQUIREMENTS_FREQAI=""
@@ -259,7 +258,7 @@ function install() {
         install_redhat
     else
         echo "This script does not support your OS."
-        echo "If you have Python version 3.8 - 3.10, pip, virtualenv, ta-lib you can continue."
+        echo "If you have Python version 3.8 - 3.11, pip, virtualenv, ta-lib you can continue."
         echo "Wait 10 seconds to continue the next install steps or use ctrl+c to interrupt this shell."
         sleep 10
     fi
diff --git a/tests/commands/test_commands.py b/tests/commands/test_commands.py
index 318590b32..fe847e94b 100644
--- a/tests/commands/test_commands.py
+++ b/tests/commands/test_commands.py
@@ -1,12 +1,11 @@
 import json
 import re
-from datetime import datetime
+from datetime import datetime, timedelta
 from io import BytesIO
 from pathlib import Path
 from unittest.mock import MagicMock, PropertyMock
 from zipfile import ZipFile
 
-import arrow
 import pytest
 
 from freqtrade.commands import (start_backtesting_show, start_convert_data, start_convert_trades,
@@ -25,6 +24,7 @@ from freqtrade.enums import RunMode
 from freqtrade.exceptions import OperationalException
 from freqtrade.persistence.models import init_db
 from freqtrade.persistence.pairlock_middleware import PairLocks
+from freqtrade.util import dt_floor_day, dt_now, dt_utc
 from tests.conftest import (CURRENT_TEST_STRATEGY, EXMS, create_mock_trades, get_args, log_has,
                             log_has_re, patch_exchange, patched_configuration_load_config_file)
 from tests.conftest_trades import MOCK_TRADE_COUNT
@@ -689,7 +689,7 @@ def test_download_data_timerange(mocker, markets):
     start_download_data(pargs)
     assert dl_mock.call_count == 1
     # 20days ago
-    days_ago = arrow.get(arrow.now().shift(days=-20).date()).int_timestamp
+    days_ago = dt_floor_day(dt_now() - timedelta(days=20)).timestamp()
     assert dl_mock.call_args_list[0][1]['timerange'].startts == days_ago
 
     dl_mock.reset_mock()
@@ -704,8 +704,7 @@ def test_download_data_timerange(mocker, markets):
     start_download_data(pargs)
     assert dl_mock.call_count == 1
 
-    assert dl_mock.call_args_list[0][1]['timerange'].startts == arrow.Arrow(
-        2020, 1, 1).int_timestamp
+    assert dl_mock.call_args_list[0][1]['timerange'].startts == int(dt_utc(2020, 1, 1).timestamp())
 
 
 def test_download_data_no_markets(mocker, caplog):
diff --git a/tests/conftest.py b/tests/conftest.py
index 2f2345d54..66f331cae 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -3,16 +3,14 @@ import json
 import logging
 import re
 from copy import deepcopy
-from datetime import datetime, timedelta
+from datetime import timedelta
 from pathlib import Path
 from typing import Optional
 from unittest.mock import MagicMock, Mock, PropertyMock
 
-import arrow
 import numpy as np
 import pandas as pd
 import pytest
-from telegram import Chat, Message, Update
 
 from freqtrade import constants
 from freqtrade.commands import Arguments
@@ -24,6 +22,8 @@ from freqtrade.exchange.exchange import timeframe_to_minutes
 from freqtrade.freqtradebot import FreqtradeBot
 from freqtrade.persistence import LocalTrade, Order, Trade, init_db
 from freqtrade.resolvers import ExchangeResolver
+from freqtrade.util import dt_ts
+from freqtrade.util.datetime_helpers import dt_now
 from freqtrade.worker import Worker
 from tests.conftest_trades import (leverage_trade, mock_trade_1, mock_trade_2, mock_trade_3,
                                    mock_trade_4, mock_trade_5, mock_trade_6, short_trade)
@@ -182,7 +182,7 @@ def get_patched_exchange(mocker, config, api_mock=None, id='binance',
     patch_exchange(mocker, api_mock, id, mock_markets, mock_supported_modes)
     config['exchange']['name'] = id
     try:
-        exchange = ExchangeResolver.load_exchange(id, config, load_leverage_tiers=True)
+        exchange = ExchangeResolver.load_exchange(config, load_leverage_tiers=True)
     except ImportError:
         exchange = Exchange(config)
     return exchange
@@ -412,6 +412,14 @@ def patch_gc(mocker) -> None:
     mocker.patch("freqtrade.main.gc_set_threshold")
 
 
+@pytest.fixture(autouse=True)
+def user_dir(mocker, tmpdir) -> Path:
+    user_dir = Path(tmpdir) / "user_data"
+    mocker.patch('freqtrade.configuration.configuration.create_userdata_dir',
+                 return_value=user_dir)
+    return user_dir
+
+
 @pytest.fixture(autouse=True)
 def patch_coingekko(mocker) -> None:
     """
@@ -486,7 +494,6 @@ def get_default_conf(testdatadir):
         },
         "exchange": {
             "name": "binance",
-            "enabled": True,
             "key": "key",
             "secret": "secret",
             "pair_whitelist": [
@@ -550,13 +557,6 @@ def get_default_conf_usdt(testdatadir):
     return configuration
 
 
-@pytest.fixture
-def update():
-    _update = Update(0)
-    _update.message = Message(0, datetime.utcnow(), Chat(0, 0))
-    return _update
-
-
 @pytest.fixture
 def fee():
     return MagicMock(return_value=0.0025)
@@ -1664,8 +1664,8 @@ def limit_buy_order_open():
         'type': 'limit',
         'side': 'buy',
         'symbol': 'mocked',
-        'timestamp': arrow.utcnow().int_timestamp * 1000,
-        'datetime': arrow.utcnow().isoformat(),
+        'timestamp': dt_ts(),
+        'datetime': dt_now().isoformat(),
         'price': 0.00001099,
         'average': 0.00001099,
         'amount': 90.99181073,
@@ -1692,8 +1692,8 @@ def limit_buy_order_old():
         'type': 'limit',
         'side': 'buy',
         'symbol': 'mocked',
-        'datetime': arrow.utcnow().shift(minutes=-601).isoformat(),
-        'timestamp': arrow.utcnow().shift(minutes=-601).int_timestamp * 1000,
+        'datetime': (dt_now() - timedelta(minutes=601)).isoformat(),
+        'timestamp': dt_ts(dt_now() - timedelta(minutes=601)),
         'price': 0.00001099,
         'amount': 90.99181073,
         'filled': 0.0,
@@ -1709,8 +1709,8 @@ def limit_sell_order_old():
         'type': 'limit',
         'side': 'sell',
         'symbol': 'ETH/BTC',
-        'timestamp': arrow.utcnow().shift(minutes=-601).int_timestamp * 1000,
-        'datetime': arrow.utcnow().shift(minutes=-601).isoformat(),
+        'timestamp': dt_ts(dt_now() - timedelta(minutes=601)),
+        'datetime': (dt_now() - timedelta(minutes=601)).isoformat(),
         'price': 0.00001099,
         'amount': 90.99181073,
         'filled': 0.0,
@@ -1726,8 +1726,8 @@ def limit_buy_order_old_partial():
         'type': 'limit',
         'side': 'buy',
         'symbol': 'ETH/BTC',
-        'timestamp': arrow.utcnow().shift(minutes=-601).int_timestamp * 1000,
-        'datetime': arrow.utcnow().shift(minutes=-601).isoformat(),
+        'timestamp': dt_ts(dt_now() - timedelta(minutes=601)),
+        'datetime': (dt_now() - timedelta(minutes=601)).isoformat(),
         'price': 0.00001099,
         'amount': 90.99181073,
         'filled': 23.0,
@@ -1757,8 +1757,8 @@ def limit_buy_order_canceled_empty(request):
             'info': {},
             'id': 'AZNPFF-4AC4N-7MKTAT',
             'clientOrderId': None,
-            'timestamp': arrow.utcnow().shift(minutes=-601).int_timestamp * 1000,
-            'datetime': arrow.utcnow().shift(minutes=-601).isoformat(),
+            'timestamp': dt_ts(dt_now() - timedelta(minutes=601)),
+            'datetime': (dt_now() - timedelta(minutes=601)).isoformat(),
             'lastTradeTimestamp': None,
             'status': 'canceled',
             'symbol': 'LTC/USDT',
@@ -1778,8 +1778,8 @@ def limit_buy_order_canceled_empty(request):
             'info': {},
             'id': '1234512345',
             'clientOrderId': 'alb1234123',
-            'timestamp': arrow.utcnow().shift(minutes=-601).int_timestamp * 1000,
-            'datetime': arrow.utcnow().shift(minutes=-601).isoformat(),
+            'timestamp': dt_ts(dt_now() - timedelta(minutes=601)),
+            'datetime': (dt_now() - timedelta(minutes=601)).isoformat(),
             'lastTradeTimestamp': None,
             'symbol': 'LTC/USDT',
             'type': 'limit',
@@ -1799,8 +1799,8 @@ def limit_buy_order_canceled_empty(request):
             'info': {},
             'id': '1234512345',
             'clientOrderId': 'alb1234123',
-            'timestamp': arrow.utcnow().shift(minutes=-601).int_timestamp * 1000,
-            'datetime': arrow.utcnow().shift(minutes=-601).isoformat(),
+            'timestamp': dt_ts(dt_now() - timedelta(minutes=601)),
+            'datetime': (dt_now() - timedelta(minutes=601)).isoformat(),
             'lastTradeTimestamp': None,
             'symbol': 'LTC/USDT',
             'type': 'limit',
@@ -1824,8 +1824,8 @@ def limit_sell_order_open():
         'type': 'limit',
         'side': 'sell',
         'symbol': 'mocked',
-        'datetime': arrow.utcnow().isoformat(),
-        'timestamp': arrow.utcnow().int_timestamp * 1000,
+        'datetime': dt_now().isoformat(),
+        'timestamp': dt_ts(),
         'price': 0.00001173,
         'amount': 90.99181073,
         'filled': 0.0,
@@ -2487,8 +2487,8 @@ def buy_order_fee():
         'type': 'limit',
         'side': 'buy',
         'symbol': 'mocked',
-        'timestamp': arrow.utcnow().shift(minutes=-601).int_timestamp * 1000,
-        'datetime': arrow.utcnow().shift(minutes=-601).isoformat(),
+        'timestamp': dt_ts(dt_now() - timedelta(minutes=601)),
+        'datetime': (dt_now() - timedelta(minutes=601)).isoformat(),
         'price': 0.245441,
         'amount': 8.0,
         'cost': 1.963528,
@@ -2597,7 +2597,7 @@ def open_trade():
         fee_open=0.0,
         fee_close=0.0,
         stake_amount=1,
-        open_date=arrow.utcnow().shift(minutes=-601).datetime,
+        open_date=dt_now() - timedelta(minutes=601),
         is_open=True
     )
     trade.orders = [
@@ -2635,7 +2635,7 @@ def open_trade_usdt():
         fee_open=0.0,
         fee_close=0.0,
         stake_amount=60.0,
-        open_date=arrow.utcnow().shift(minutes=-601).datetime,
+        open_date=dt_now() - timedelta(minutes=601),
         is_open=True
     )
     trade.orders = [
@@ -2839,8 +2839,8 @@ def limit_buy_order_usdt_open():
         'type': 'limit',
         'side': 'buy',
         'symbol': 'mocked',
-        'datetime': arrow.utcnow().isoformat(),
-        'timestamp': arrow.utcnow().int_timestamp * 1000,
+        'datetime': dt_now().isoformat(),
+        'timestamp': dt_ts(),
         'price': 2.00,
         'average': 2.00,
         'amount': 30.0,
@@ -2867,8 +2867,8 @@ def limit_sell_order_usdt_open():
         'type': 'limit',
         'side': 'sell',
         'symbol': 'mocked',
-        'datetime': arrow.utcnow().isoformat(),
-        'timestamp': arrow.utcnow().int_timestamp * 1000,
+        'datetime': dt_now().isoformat(),
+        'timestamp': dt_ts(),
         'price': 2.20,
         'amount': 30.0,
         'cost': 66.0,
@@ -2894,8 +2894,8 @@ def market_buy_order_usdt():
         'type': 'market',
         'side': 'buy',
         'symbol': 'mocked',
-        'timestamp': arrow.utcnow().int_timestamp * 1000,
-        'datetime': arrow.utcnow().isoformat(),
+        'timestamp': dt_ts(),
+        'datetime': dt_now().isoformat(),
         'price': 2.00,
         'amount': 30.0,
         'filled': 30.0,
@@ -2951,8 +2951,8 @@ def market_sell_order_usdt():
         'type': 'market',
         'side': 'sell',
         'symbol': 'mocked',
-        'timestamp': arrow.utcnow().int_timestamp * 1000,
-        'datetime': arrow.utcnow().isoformat(),
+        'timestamp': dt_ts(),
+        'datetime': dt_now().isoformat(),
         'price': 2.20,
         'amount': 30.0,
         'filled': 30.0,
diff --git a/tests/data/test_btanalysis.py b/tests/data/test_btanalysis.py
index 2c5515f7c..5e377f851 100644
--- a/tests/data/test_btanalysis.py
+++ b/tests/data/test_btanalysis.py
@@ -1,8 +1,8 @@
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from unittest.mock import MagicMock
 
 import pytest
-from arrow import Arrow
 from pandas import DataFrame, DateOffset, Timestamp, to_datetime
 
 from freqtrade.configuration import TimeRange
@@ -18,6 +18,7 @@ from freqtrade.data.metrics import (calculate_cagr, calculate_calmar, calculate_
                                     calculate_underwater, combine_dataframes_with_mean,
                                     create_cum_profit)
 from freqtrade.exceptions import OperationalException
+from freqtrade.util import dt_utc
 from tests.conftest import CURRENT_TEST_STRATEGY, create_mock_trades
 from tests.conftest_trades import MOCK_TRADE_COUNT
 
@@ -162,25 +163,25 @@ def test_extract_trades_of_period(testdatadir):
         {'pair': [pair, pair, pair, pair],
          'profit_ratio': [0.0, 0.1, -0.2, -0.5],
          'profit_abs': [0.0, 1, -2, -5],
-         'open_date': to_datetime([Arrow(2017, 11, 13, 15, 40, 0).datetime,
-                                   Arrow(2017, 11, 14, 9, 41, 0).datetime,
-                                   Arrow(2017, 11, 14, 14, 20, 0).datetime,
-                                   Arrow(2017, 11, 15, 3, 40, 0).datetime,
+         'open_date': to_datetime([datetime(2017, 11, 13, 15, 40, 0, tzinfo=timezone.utc),
+                                   datetime(2017, 11, 14, 9, 41, 0, tzinfo=timezone.utc),
+                                   datetime(2017, 11, 14, 14, 20, 0, tzinfo=timezone.utc),
+                                   datetime(2017, 11, 15, 3, 40, 0, tzinfo=timezone.utc),
                                    ], utc=True
                                   ),
-         'close_date': to_datetime([Arrow(2017, 11, 13, 16, 40, 0).datetime,
-                                    Arrow(2017, 11, 14, 10, 41, 0).datetime,
-                                    Arrow(2017, 11, 14, 15, 25, 0).datetime,
-                                    Arrow(2017, 11, 15, 3, 55, 0).datetime,
+         'close_date': to_datetime([datetime(2017, 11, 13, 16, 40, 0, tzinfo=timezone.utc),
+                                    datetime(2017, 11, 14, 10, 41, 0, tzinfo=timezone.utc),
+                                    datetime(2017, 11, 14, 15, 25, 0, tzinfo=timezone.utc),
+                                    datetime(2017, 11, 15, 3, 55, 0, tzinfo=timezone.utc),
                                     ], utc=True)
          })
     trades1 = extract_trades_of_period(data, trades)
     # First and last trade are dropped as they are out of range
     assert len(trades1) == 2
-    assert trades1.iloc[0].open_date == Arrow(2017, 11, 14, 9, 41, 0).datetime
-    assert trades1.iloc[0].close_date == Arrow(2017, 11, 14, 10, 41, 0).datetime
-    assert trades1.iloc[-1].open_date == Arrow(2017, 11, 14, 14, 20, 0).datetime
-    assert trades1.iloc[-1].close_date == Arrow(2017, 11, 14, 15, 25, 0).datetime
+    assert trades1.iloc[0].open_date == datetime(2017, 11, 14, 9, 41, 0, tzinfo=timezone.utc)
+    assert trades1.iloc[0].close_date == datetime(2017, 11, 14, 10, 41, 0, tzinfo=timezone.utc)
+    assert trades1.iloc[-1].open_date == datetime(2017, 11, 14, 14, 20, 0, tzinfo=timezone.utc)
+    assert trades1.iloc[-1].close_date == datetime(2017, 11, 14, 15, 25, 0, tzinfo=timezone.utc)
 
 
 def test_analyze_trade_parallelism(testdatadir):
@@ -420,7 +421,7 @@ def test_calculate_max_drawdown2():
               -0.025782, 0.010400, 0.012374, 0.012467, 0.114741, 0.010303, 0.010088,
               -0.033961, 0.010680, 0.010886, -0.029274, 0.011178, 0.010693, 0.010711]
 
-    dates = [Arrow(2020, 1, 1).shift(days=i) for i in range(len(values))]
+    dates = [dt_utc(2020, 1, 1) + timedelta(days=i) for i in range(len(values))]
     df = DataFrame(zip(values, dates), columns=['profit', 'open_date'])
     # sort by profit and reset index
     df = df.sort_values('profit').reset_index(drop=True)
@@ -454,8 +455,8 @@ def test_calculate_max_drawdown_abs(profits, relative, highd, lowd, result, resu
     [1000, 500,  1000, 11000, 10000] # absolute results
     [1000, 50%,  0%,   0%,       ~9%]   # Relative drawdowns
     """
-    init_date = Arrow(2020, 1, 1)
-    dates = [init_date.shift(days=i) for i in range(len(profits))]
+    init_date = datetime(2020, 1, 1, tzinfo=timezone.utc)
+    dates = [init_date + timedelta(days=i) for i in range(len(profits))]
     df = DataFrame(zip(profits, dates), columns=['profit_abs', 'open_date'])
     # sort by profit and reset index
     df = df.sort_values('profit_abs').reset_index(drop=True)
@@ -467,8 +468,8 @@ def test_calculate_max_drawdown_abs(profits, relative, highd, lowd, result, resu
 
     assert isinstance(drawdown, float)
     assert isinstance(drawdown_rel, float)
-    assert hdate == init_date.shift(days=highd)
-    assert ldate == init_date.shift(days=lowd)
+    assert hdate == init_date + timedelta(days=highd)
+    assert ldate == init_date + timedelta(days=lowd)
 
     # High must be before low
     assert hdate < ldate
diff --git a/tests/data/test_entryexitanalysis.py b/tests/data/test_entryexitanalysis.py
index 3b073bc32..810e2c53b 100644
--- a/tests/data/test_entryexitanalysis.py
+++ b/tests/data/test_entryexitanalysis.py
@@ -18,8 +18,9 @@ def entryexitanalysis_cleanup() -> None:
     Backtesting.cleanup()
 
 
-def test_backtest_analysis_nomock(default_conf, mocker, caplog, testdatadir, tmpdir, capsys):
+def test_backtest_analysis_nomock(default_conf, mocker, caplog, testdatadir, user_dir, capsys):
     caplog.set_level(logging.INFO)
+    (user_dir / 'backtest_results').mkdir(parents=True, exist_ok=True)
 
     default_conf.update({
         "use_exit_signal": True,
@@ -80,7 +81,7 @@ def test_backtest_analysis_nomock(default_conf, mocker, caplog, testdatadir, tmp
         'backtesting',
         '--config', 'config.json',
         '--datadir', str(testdatadir),
-        '--user-data-dir', str(tmpdir),
+        '--user-data-dir', str(user_dir),
         '--timeframe', '5m',
         '--timerange', '1515560100-1517287800',
         '--export', 'signals',
@@ -98,7 +99,7 @@ def test_backtest_analysis_nomock(default_conf, mocker, caplog, testdatadir, tmp
         'backtesting-analysis',
         '--config', 'config.json',
         '--datadir', str(testdatadir),
-        '--user-data-dir', str(tmpdir),
+        '--user-data-dir', str(user_dir),
     ]
 
     # test group 0 and indicator list
@@ -200,8 +201,17 @@ def test_backtest_analysis_nomock(default_conf, mocker, caplog, testdatadir, tmp
     assert 'trailing_stop_loss' in captured.out
 
     # test date filtering
-    args = get_args(base_args + ['--timerange', "20180129-20180130"])
+    args = get_args(base_args +
+                    ['--analysis-groups', "0", "1", "2",
+                     '--timerange', "20180129-20180130"]
+                    )
     start_analysis_entries_exits(args)
     captured = capsys.readouterr()
     assert 'enter_tag_long_a' in captured.out
     assert 'enter_tag_long_b' not in captured.out
+
+    # Due to the backtest mock, there's no rejected signals generated.
+    args = get_args(base_args + ['--rejected-signals'])
+    start_analysis_entries_exits(args)
+    captured = capsys.readouterr()
+    assert 'no rejected signals' in captured.out
diff --git a/tests/data/test_history.py b/tests/data/test_history.py
index 24ad8bcc9..e397c97c1 100644
--- a/tests/data/test_history.py
+++ b/tests/data/test_history.py
@@ -6,7 +6,6 @@ from pathlib import Path
 from shutil import copyfile
 from unittest.mock import MagicMock, PropertyMock
 
-import arrow
 import pytest
 from pandas import DataFrame
 from pandas.testing import assert_frame_equal
@@ -26,6 +25,7 @@ from freqtrade.enums import CandleType
 from freqtrade.exchange import timeframe_to_minutes
 from freqtrade.misc import file_dump_json
 from freqtrade.resolvers import StrategyResolver
+from freqtrade.util import dt_utc
 from tests.conftest import (CURRENT_TEST_STRATEGY, EXMS, get_patched_exchange, log_has, log_has_re,
                             patch_exchange)
 
@@ -198,7 +198,6 @@ def test_load_cached_data_for_updating(mocker, testdatadir) -> None:
                                       fill_missing=False, drop_incomplete=False)
     # now = last cached item + 1 hour
     now_ts = test_data[-1][0] / 1000 + 60 * 60
-    mocker.patch('arrow.utcnow', return_value=arrow.get(now_ts))
 
     # timeframe starts earlier than the cached data
     # should fully update data
@@ -353,10 +352,10 @@ def test_download_backtesting_data_exception(mocker, caplog, default_conf, tmpdi
 
 def test_load_partial_missing(testdatadir, caplog) -> None:
     # Make sure we start fresh - test missing data at start
-    start = arrow.get('2018-01-01T00:00:00')
-    end = arrow.get('2018-01-11T00:00:00')
+    start = dt_utc(2018, 1, 1)
+    end = dt_utc(2018, 1, 11)
     data = load_data(testdatadir, '5m', ['UNITTEST/BTC'], startup_candles=20,
-                     timerange=TimeRange('date', 'date', start.int_timestamp, end.int_timestamp))
+                     timerange=TimeRange('date', 'date', start.timestamp(), end.timestamp()))
     assert log_has(
         'Using indicator startup period: 20 ...', caplog
     )
@@ -369,16 +368,16 @@ def test_load_partial_missing(testdatadir, caplog) -> None:
                    caplog)
     # Make sure we start fresh - test missing data at end
     caplog.clear()
-    start = arrow.get('2018-01-10T00:00:00')
-    end = arrow.get('2018-02-20T00:00:00')
+    start = dt_utc(2018, 1, 10)
+    end = dt_utc(2018, 2, 20)
     data = load_data(datadir=testdatadir, timeframe='5m', pairs=['UNITTEST/BTC'],
-                     timerange=TimeRange('date', 'date', start.int_timestamp, end.int_timestamp))
+                     timerange=TimeRange('date', 'date', start.timestamp(), end.timestamp()))
     # timedifference in 5 minutes
     td = ((end - start).total_seconds() // 60 // 5) + 1
     assert td != len(data['UNITTEST/BTC'])
 
     # Shift endtime with +5
-    end_real = arrow.get(data['UNITTEST/BTC'].iloc[-1, 0])
+    end_real = data['UNITTEST/BTC'].iloc[-1, 0].to_pydatetime()
     assert log_has(f'UNITTEST/BTC, spot, 5m, '
                    f'data ends at {end_real.strftime(DATETIME_PRINT_FORMAT)}',
                    caplog)
diff --git a/tests/edge/test_edge.py b/tests/edge/test_edge.py
index be0346b78..4829dd035 100644
--- a/tests/edge/test_edge.py
+++ b/tests/edge/test_edge.py
@@ -3,9 +3,9 @@
 
 import logging
 import math
+from datetime import timedelta
 from unittest.mock import MagicMock
 
-import arrow
 import numpy as np
 import pytest
 from pandas import DataFrame
@@ -14,6 +14,7 @@ from freqtrade.data.converter import ohlcv_to_dataframe
 from freqtrade.edge import Edge, PairInfo
 from freqtrade.enums import ExitType
 from freqtrade.exceptions import OperationalException
+from freqtrade.util.datetime_helpers import dt_ts, dt_utc
 from tests.conftest import EXMS, get_patched_freqtradebot, log_has
 from tests.optimize import (BTContainer, BTrade, _build_backtest_dataframe,
                             _get_frame_time_from_offset)
@@ -27,7 +28,7 @@ from tests.optimize import (BTContainer, BTrade, _build_backtest_dataframe,
 # 5) Stoploss and sell are hit. should sell on stoploss
 ####################################################################
 
-tests_start_time = arrow.get(2018, 10, 3)
+tests_start_time = dt_utc(2018, 10, 3)
 timeframe_in_minute = 60
 
 # End helper functions
@@ -220,7 +221,7 @@ def test_edge_heartbeat_calculate(mocker, edge_conf):
     heartbeat = edge_conf['edge']['process_throttle_secs']
 
     # should not recalculate if heartbeat not reached
-    edge._last_updated = arrow.utcnow().int_timestamp - heartbeat + 1
+    edge._last_updated = dt_ts() - heartbeat + 1
 
     assert edge.calculate(edge_conf['exchange']['pair_whitelist']) is False
 
@@ -232,7 +233,7 @@ def mocked_load_data(datadir, pairs=[], timeframe='0m',
 
     NEOBTC = [
         [
-            tests_start_time.shift(minutes=(x * timeframe_in_minute)).int_timestamp * 1000,
+            dt_ts(tests_start_time + timedelta(minutes=(x * timeframe_in_minute))),
             math.sin(x * hz) / 1000 + base,
             math.sin(x * hz) / 1000 + base + 0.0001,
             math.sin(x * hz) / 1000 + base - 0.0001,
@@ -244,7 +245,7 @@ def mocked_load_data(datadir, pairs=[], timeframe='0m',
     base = 0.002
     LTCBTC = [
         [
-            tests_start_time.shift(minutes=(x * timeframe_in_minute)).int_timestamp * 1000,
+            dt_ts(tests_start_time + timedelta(minutes=(x * timeframe_in_minute))),
             math.sin(x * hz) / 1000 + base,
             math.sin(x * hz) / 1000 + base + 0.0001,
             math.sin(x * hz) / 1000 + base - 0.0001,
@@ -268,7 +269,7 @@ def test_edge_process_downloaded_data(mocker, edge_conf):
 
     assert edge.calculate(edge_conf['exchange']['pair_whitelist'])
     assert len(edge._cached_pairs) == 2
-    assert edge._last_updated <= arrow.utcnow().int_timestamp + 2
+    assert edge._last_updated <= dt_ts() + 2
 
 
 def test_edge_process_no_data(mocker, edge_conf, caplog):
diff --git a/tests/exchange/test_binance.py b/tests/exchange/test_binance.py
index d44dae00d..9018d2db9 100644
--- a/tests/exchange/test_binance.py
+++ b/tests/exchange/test_binance.py
@@ -514,7 +514,7 @@ def test_fill_leverage_tiers_binance_dryrun(default_conf, mocker, leverage_tiers
 
 def test_additional_exchange_init_binance(default_conf, mocker):
     api_mock = MagicMock()
-    api_mock.fapiPrivateGetPositionsideDual = MagicMock(return_value={"dualSidePosition": True})
+    api_mock.fapiPrivateGetPositionSideDual = MagicMock(return_value={"dualSidePosition": True})
     api_mock.fapiPrivateGetMultiAssetsMargin = MagicMock(return_value={"multiAssetsMargin": True})
     default_conf['dry_run'] = False
     default_conf['trading_mode'] = TradingMode.FUTURES
@@ -522,12 +522,12 @@ def test_additional_exchange_init_binance(default_conf, mocker):
     with pytest.raises(OperationalException,
                        match=r"Hedge Mode is not supported.*\nMulti-Asset Mode is not supported.*"):
         get_patched_exchange(mocker, default_conf, id="binance", api_mock=api_mock)
-    api_mock.fapiPrivateGetPositionsideDual = MagicMock(return_value={"dualSidePosition": False})
+    api_mock.fapiPrivateGetPositionSideDual = MagicMock(return_value={"dualSidePosition": False})
     api_mock.fapiPrivateGetMultiAssetsMargin = MagicMock(return_value={"multiAssetsMargin": False})
     exchange = get_patched_exchange(mocker, default_conf, id="binance", api_mock=api_mock)
     assert exchange
     ccxt_exceptionhandlers(mocker, default_conf, api_mock, 'binance',
-                           "additional_exchange_init", "fapiPrivateGetPositionsideDual")
+                           "additional_exchange_init", "fapiPrivateGetPositionSideDual")
 
 
 def test__set_leverage_binance(mocker, default_conf):
diff --git a/tests/exchange/test_ccxt_compat.py b/tests/exchange/test_ccxt_compat.py
index 60855ca54..404b51d10 100644
--- a/tests/exchange/test_ccxt_compat.py
+++ b/tests/exchange/test_ccxt_compat.py
@@ -43,6 +43,10 @@ EXCHANGES = {
         'hasQuoteVolumeFutures': True,
         'leverage_tiers_public': False,
         'leverage_in_spot_market': False,
+        'private_methods': [
+            'fapiPrivateGetPositionSideDual',
+            'fapiPrivateGetMultiAssetsMargin'
+        ],
         'sample_order': [{
             "symbol": "SOLUSDT",
             "orderId": 3551312894,
@@ -221,11 +225,13 @@ EXCHANGES = {
         'hasQuoteVolumeFutures': False,
         'leverage_tiers_public': True,
         'leverage_in_spot_market': True,
+        'private_methods': ['fetch_accounts'],
     },
     'bybit': {
         'pair': 'BTC/USDT',
         'stake_currency': 'USDT',
         'hasQuoteVolume': True,
+        'use_ci_proxy': True,
         'timeframe': '1h',
         'futures_pair': 'BTC/USDT:USDT',
         'futures': True,
@@ -302,7 +308,7 @@ def exchange(request, exchange_conf):
         exchange_conf, EXCHANGES[request.param].get('use_ci_proxy', False))
     exchange_conf['exchange']['name'] = request.param
     exchange_conf['stake_currency'] = EXCHANGES[request.param]['stake_currency']
-    exchange = ExchangeResolver.load_exchange(request.param, exchange_conf, validate=True)
+    exchange = ExchangeResolver.load_exchange(exchange_conf, validate=True)
 
     yield exchange, request.param
 
@@ -330,7 +336,7 @@ def exchange_futures(request, exchange_conf, class_mocker):
         class_mocker.patch(f'{EXMS}.cache_leverage_tiers')
 
         exchange = ExchangeResolver.load_exchange(
-            request.param, exchange_conf, validate=True, load_leverage_tiers=True)
+            exchange_conf, validate=True, load_leverage_tiers=True)
 
         yield exchange, request.param
 
@@ -755,3 +761,8 @@ class TestCCXTExchange():
             max_stake_amount = futures.get_max_pair_stake_amount(futures_pair, 40000)
             assert (isinstance(max_stake_amount, float))
             assert max_stake_amount >= 0.0
+
+    def test_private_method_presence(self, exchange: EXCHANGE_FIXTURE_TYPE):
+        exch, exchangename = exchange
+        for method in EXCHANGES[exchangename].get('private_methods', []):
+            assert hasattr(exch._api, method)
diff --git a/tests/exchange/test_exchange.py b/tests/exchange/test_exchange.py
index b0760944a..ef70c8ba1 100644
--- a/tests/exchange/test_exchange.py
+++ b/tests/exchange/test_exchange.py
@@ -5,7 +5,6 @@ from datetime import datetime, timedelta, timezone
 from random import randint
 from unittest.mock import MagicMock, Mock, PropertyMock, patch
 
-import arrow
 import ccxt
 import pytest
 from ccxt import DECIMAL_PLACES, ROUND, ROUND_UP, TICK_SIZE, TRUNCATE
@@ -20,9 +19,10 @@ from freqtrade.exchange import (Binance, Bittrex, Exchange, Kraken, amount_to_pr
                                 timeframe_to_minutes, timeframe_to_msecs, timeframe_to_next_date,
                                 timeframe_to_prev_date, timeframe_to_seconds)
 from freqtrade.exchange.common import (API_FETCH_ORDER_RETRY_COUNT, API_RETRY_COUNT,
-                                       calculate_backoff, remove_credentials)
+                                       calculate_backoff, remove_exchange_credentials)
 from freqtrade.exchange.exchange import amount_to_contract_precision
 from freqtrade.resolvers.exchange_resolver import ExchangeResolver
+from freqtrade.util import dt_now, dt_ts
 from tests.conftest import (EXMS, generate_test_data_raw, get_mock_coro, get_patched_exchange,
                             log_has, log_has_re, num_log_has_re)
 
@@ -137,16 +137,14 @@ def test_init(default_conf, mocker, caplog):
     assert log_has('Instance is running with dry_run enabled', caplog)
 
 
-def test_remove_credentials(default_conf, caplog) -> None:
+def test_remove_exchange_credentials(default_conf) -> None:
     conf = deepcopy(default_conf)
-    conf['dry_run'] = False
-    remove_credentials(conf)
+    remove_exchange_credentials(conf['exchange'], False)
 
     assert conf['exchange']['key'] != ''
     assert conf['exchange']['secret'] != ''
 
-    conf['dry_run'] = True
-    remove_credentials(conf)
+    remove_exchange_credentials(conf['exchange'], True)
     assert conf['exchange']['key'] == ''
     assert conf['exchange']['secret'] == ''
     assert conf['exchange']['password'] == ''
@@ -228,27 +226,30 @@ def test_exchange_resolver(default_conf, mocker, caplog):
     mocker.patch(f'{EXMS}.validate_timeframes')
     mocker.patch(f'{EXMS}.validate_stakecurrency')
     mocker.patch(f'{EXMS}.validate_pricing')
-
-    exchange = ExchangeResolver.load_exchange('zaif', default_conf)
+    default_conf['exchange']['name'] = 'zaif'
+    exchange = ExchangeResolver.load_exchange(default_conf)
     assert isinstance(exchange, Exchange)
     assert log_has_re(r"No .* specific subclass found. Using the generic class instead.", caplog)
     caplog.clear()
 
-    exchange = ExchangeResolver.load_exchange('Bittrex', default_conf)
+    default_conf['exchange']['name'] = 'Bittrex'
+    exchange = ExchangeResolver.load_exchange(default_conf)
     assert isinstance(exchange, Exchange)
     assert isinstance(exchange, Bittrex)
     assert not log_has_re(r"No .* specific subclass found. Using the generic class instead.",
                           caplog)
     caplog.clear()
 
-    exchange = ExchangeResolver.load_exchange('kraken', default_conf)
+    default_conf['exchange']['name'] = 'kraken'
+    exchange = ExchangeResolver.load_exchange(default_conf)
     assert isinstance(exchange, Exchange)
     assert isinstance(exchange, Kraken)
     assert not isinstance(exchange, Binance)
     assert not log_has_re(r"No .* specific subclass found. Using the generic class instead.",
                           caplog)
 
-    exchange = ExchangeResolver.load_exchange('binance', default_conf)
+    default_conf['exchange']['name'] = 'binance'
+    exchange = ExchangeResolver.load_exchange(default_conf)
     assert isinstance(exchange, Exchange)
     assert isinstance(exchange, Binance)
     assert not isinstance(exchange, Kraken)
@@ -257,7 +258,8 @@ def test_exchange_resolver(default_conf, mocker, caplog):
                           caplog)
 
     # Test mapping
-    exchange = ExchangeResolver.load_exchange('binanceus', default_conf)
+    default_conf['exchange']['name'] = 'binanceus'
+    exchange = ExchangeResolver.load_exchange(default_conf)
     assert isinstance(exchange, Exchange)
     assert isinstance(exchange, Binance)
     assert not isinstance(exchange, Kraken)
@@ -642,7 +644,7 @@ def test_reload_markets(default_conf, mocker, caplog):
     exchange = get_patched_exchange(mocker, default_conf, api_mock, id="binance",
                                     mock_markets=False)
     exchange._load_async_markets = MagicMock()
-    exchange._last_markets_refresh = arrow.utcnow().int_timestamp
+    exchange._last_markets_refresh = dt_ts()
 
     assert exchange.markets == initial_markets
 
@@ -653,7 +655,7 @@ def test_reload_markets(default_conf, mocker, caplog):
 
     api_mock.load_markets = MagicMock(return_value=updated_markets)
     # more than 10 minutes have passed, reload is executed
-    exchange._last_markets_refresh = arrow.utcnow().int_timestamp - 15 * 60
+    exchange._last_markets_refresh = dt_ts(dt_now() - timedelta(minutes=15))
     exchange.reload_markets()
     assert exchange.markets == updated_markets
     assert exchange._load_async_markets.call_count == 1
@@ -990,19 +992,20 @@ def test_validate_pricing(default_conf, mocker):
     mocker.patch(f'{EXMS}.validate_timeframes')
     mocker.patch(f'{EXMS}.validate_stakecurrency')
     mocker.patch(f'{EXMS}.name', 'Binance')
-    ExchangeResolver.load_exchange('binance', default_conf)
+    default_conf['exchange']['name'] = 'binance'
+    ExchangeResolver.load_exchange(default_conf)
     has.update({'fetchTicker': False})
     with pytest.raises(OperationalException, match="Ticker pricing not available for .*"):
-        ExchangeResolver.load_exchange('binance', default_conf)
+        ExchangeResolver.load_exchange(default_conf)
 
     has.update({'fetchTicker': True})
 
     default_conf['exit_pricing']['use_order_book'] = True
-    ExchangeResolver.load_exchange('binance', default_conf)
+    ExchangeResolver.load_exchange(default_conf)
     has.update({'fetchL2OrderBook': False})
 
     with pytest.raises(OperationalException, match="Orderbook not available for .*"):
-        ExchangeResolver.load_exchange('binance', default_conf)
+        ExchangeResolver.load_exchange(default_conf)
 
     has.update({'fetchL2OrderBook': True})
 
@@ -1011,7 +1014,7 @@ def test_validate_pricing(default_conf, mocker):
     default_conf['margin_mode'] = MarginMode.ISOLATED
 
     with pytest.raises(OperationalException, match="Ticker pricing not available for .*"):
-        ExchangeResolver.load_exchange('binance', default_conf)
+        ExchangeResolver.load_exchange(default_conf)
 
 
 def test_validate_ordertypes(default_conf, mocker):
@@ -1091,12 +1094,13 @@ def test_validate_ordertypes_stop_advanced(default_conf, mocker, exchange_name,
         'stoploss_on_exchange': True,
         'stoploss_price_type': stopadv,
     }
+    default_conf['exchange']['name'] = exchange_name
     if expected:
-        ExchangeResolver.load_exchange(exchange_name, default_conf)
+        ExchangeResolver.load_exchange(default_conf)
     else:
         with pytest.raises(OperationalException,
                            match=r'On exchange stoploss price type is not supported for .*'):
-            ExchangeResolver.load_exchange(exchange_name, default_conf)
+            ExchangeResolver.load_exchange(default_conf)
 
 
 def test_validate_order_types_not_in_config(default_conf, mocker):
@@ -1773,6 +1777,71 @@ def test_fetch_positions(default_conf, mocker, exchange_name):
                            "fetch_positions", "fetch_positions")
 
 
+@pytest.mark.parametrize("exchange_name", EXCHANGES)
+def test_fetch_orders(default_conf, mocker, exchange_name, limit_order):
+
+    api_mock = MagicMock()
+    api_mock.fetch_orders = MagicMock(return_value=[
+        limit_order['buy'],
+        limit_order['sell'],
+    ])
+    api_mock.fetch_open_orders = MagicMock(return_value=[limit_order['buy']])
+    api_mock.fetch_closed_orders = MagicMock(return_value=[limit_order['buy']])
+
+    mocker.patch(f'{EXMS}.exchange_has', return_value=True)
+    start_time = datetime.now(timezone.utc) - timedelta(days=5)
+
+    exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
+    # Not available in dry-run
+    assert exchange.fetch_orders('mocked', start_time) == []
+    assert api_mock.fetch_orders.call_count == 0
+    default_conf['dry_run'] = False
+
+    exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
+    res = exchange.fetch_orders('mocked', start_time)
+    assert api_mock.fetch_orders.call_count == 1
+    assert api_mock.fetch_open_orders.call_count == 0
+    assert api_mock.fetch_closed_orders.call_count == 0
+    assert len(res) == 2
+
+    res = exchange.fetch_orders('mocked', start_time)
+
+    api_mock.fetch_orders.reset_mock()
+
+    def has_resp(_, endpoint):
+        if endpoint == 'fetchOrders':
+            return False
+        if endpoint == 'fetchClosedOrders':
+            return True
+        if endpoint == 'fetchOpenOrders':
+            return True
+
+    mocker.patch(f'{EXMS}.exchange_has', has_resp)
+
+    # happy path without fetchOrders
+    res = exchange.fetch_orders('mocked', start_time)
+    assert api_mock.fetch_orders.call_count == 0
+    assert api_mock.fetch_open_orders.call_count == 1
+    assert api_mock.fetch_closed_orders.call_count == 1
+
+    mocker.patch(f'{EXMS}.exchange_has', return_value=True)
+
+    ccxt_exceptionhandlers(mocker, default_conf, api_mock, exchange_name,
+                           "fetch_orders", "fetch_orders", retries=1,
+                           pair='mocked', since=start_time)
+
+    # Unhappy path - first fetch-orders call fails.
+    api_mock.fetch_orders = MagicMock(side_effect=ccxt.NotSupported())
+    api_mock.fetch_open_orders.reset_mock()
+    api_mock.fetch_closed_orders.reset_mock()
+
+    res = exchange.fetch_orders('mocked', start_time)
+
+    assert api_mock.fetch_orders.call_count == 1
+    assert api_mock.fetch_open_orders.call_count == 1
+    assert api_mock.fetch_closed_orders.call_count == 1
+
+
 def test_fetch_trading_fees(default_conf, mocker):
     api_mock = MagicMock()
     tick = {
@@ -2007,7 +2076,7 @@ def test_get_historic_ohlcv(default_conf, mocker, caplog, exchange_name, candle_
     exchange = get_patched_exchange(mocker, default_conf, id=exchange_name)
     ohlcv = [
         [
-            arrow.utcnow().int_timestamp * 1000,  # unix timestamp ms
+            dt_ts(),  # unix timestamp ms
             1,  # open
             2,  # high
             3,  # low
@@ -2027,7 +2096,7 @@ def test_get_historic_ohlcv(default_conf, mocker, caplog, exchange_name, candle_
     ret = exchange.get_historic_ohlcv(
         pair,
         "5m",
-        int((arrow.utcnow().int_timestamp - since) * 1000),
+        dt_ts(dt_now() - timedelta(seconds=since)),
         candle_type=candle_type
     )
 
@@ -2045,7 +2114,7 @@ def test_get_historic_ohlcv(default_conf, mocker, caplog, exchange_name, candle_
     ret = exchange.get_historic_ohlcv(
         pair,
         "5m",
-        int((arrow.utcnow().int_timestamp - since) * 1000),
+        dt_ts(dt_now() - timedelta(seconds=since)),
         candle_type=candle_type
     )
     assert log_has_re(r"Async code raised an exception: .*", caplog)
@@ -2097,7 +2166,7 @@ async def test__async_get_historic_ohlcv(default_conf, mocker, caplog, exchange_
 def test_refresh_latest_ohlcv(mocker, default_conf, caplog, candle_type) -> None:
     ohlcv = [
         [
-            (arrow.utcnow().shift(minutes=-5).int_timestamp) * 1000,  # unix timestamp ms
+            dt_ts(dt_now() - timedelta(minutes=5)),  # unix timestamp ms
             1,  # open
             2,  # high
             3,  # low
@@ -2105,7 +2174,7 @@ def test_refresh_latest_ohlcv(mocker, default_conf, caplog, candle_type) -> None
             5,  # volume (in quote currency)
         ],
         [
-            arrow.utcnow().int_timestamp * 1000,  # unix timestamp ms
+            dt_ts(),  # unix timestamp ms
             3,  # open
             1,  # high
             4,  # low
@@ -2295,7 +2364,7 @@ def test_refresh_latest_ohlcv_cache(mocker, default_conf, candle_type, time_mach
 async def test__async_get_candle_history(default_conf, mocker, caplog, exchange_name):
     ohlcv = [
         [
-            arrow.utcnow().int_timestamp * 1000,  # unix timestamp ms
+            dt_ts(),  # unix timestamp ms
             1,  # open
             2,  # high
             3,  # low
@@ -2332,7 +2401,7 @@ async def test__async_get_candle_history(default_conf, mocker, caplog, exchange_
         api_mock.fetch_ohlcv = MagicMock(side_effect=ccxt.BaseError("Unknown error"))
         exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
         await exchange._async_get_candle_history(pair, "5m", CandleType.SPOT,
-                                                 (arrow.utcnow().int_timestamp - 2000) * 1000)
+                                                 dt_ts(dt_now() - timedelta(seconds=2000)))
 
     exchange.close()
 
@@ -2341,7 +2410,7 @@ async def test__async_get_candle_history(default_conf, mocker, caplog, exchange_
         api_mock.fetch_ohlcv = MagicMock(side_effect=ccxt.NotSupported("Not supported"))
         exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
         await exchange._async_get_candle_history(pair, "5m", CandleType.SPOT,
-                                                 (arrow.utcnow().int_timestamp - 2000) * 1000)
+                                                 dt_ts(dt_now() - timedelta(seconds=2000)))
     exchange.close()
 
 
@@ -2364,7 +2433,7 @@ async def test__async_kucoin_get_candle_history(default_conf, mocker, caplog):
         with pytest.raises(DDosProtection, match=r'429 Too Many Requests'):
             await exchange._async_get_candle_history(
                 "ETH/BTC", "5m", CandleType.SPOT,
-                since_ms=(arrow.utcnow().int_timestamp - 2000) * 1000, count=3)
+                since_ms=dt_ts(dt_now() - timedelta(seconds=2000)), count=3)
     assert num_log_has_re(msg, caplog) == 3
 
     caplog.clear()
@@ -2381,7 +2450,7 @@ async def test__async_kucoin_get_candle_history(default_conf, mocker, caplog):
             with pytest.raises(DDosProtection, match=r'429 Too Many Requests'):
                 await exchange._async_get_candle_history(
                     "ETH/BTC", "5m", CandleType.SPOT,
-                    (arrow.utcnow().int_timestamp - 2000) * 1000, count=3)
+                    dt_ts(dt_now() - timedelta(seconds=2000)), count=3)
         # Expect the "returned exception" message 12 times (4 retries * 3 (loop))
         assert num_log_has_re(msg, caplog) == 12
         assert num_log_has_re(msg2, caplog) == 9
@@ -2839,14 +2908,14 @@ async def test__async_fetch_trades(default_conf, mocker, caplog, exchange_name,
     with pytest.raises(OperationalException, match=r'Could not fetch trade data*'):
         api_mock.fetch_trades = MagicMock(side_effect=ccxt.BaseError("Unknown error"))
         exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
-        await exchange._async_fetch_trades(pair, since=(arrow.utcnow().int_timestamp - 2000) * 1000)
+        await exchange._async_fetch_trades(pair, since=dt_ts(dt_now() - timedelta(seconds=2000)))
     exchange.close()
 
     with pytest.raises(OperationalException, match=r'Exchange.* does not support fetching '
                                                    r'historical trade data\..*'):
         api_mock.fetch_trades = MagicMock(side_effect=ccxt.NotSupported("Not supported"))
         exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
-        await exchange._async_fetch_trades(pair, since=(arrow.utcnow().int_timestamp - 2000) * 1000)
+        await exchange._async_fetch_trades(pair, since=dt_ts(dt_now() - timedelta(seconds=2000)))
     exchange.close()
 
 
@@ -4932,7 +5001,7 @@ def test_get_maintenance_ratio_and_amt_exceptions(mocker, default_conf, leverage
 
     exchange._leverage_tiers = leverage_tiers
     with pytest.raises(
-        OperationalException,
+        DependencyException,
         match='nominal value can not be lower than 0',
     ):
         exchange.get_maintenance_ratio_and_amt('1000SHIB/USDT:USDT', -1)
diff --git a/tests/freqai/conftest.py b/tests/freqai/conftest.py
index ab4a62a9e..4c4891ceb 100644
--- a/tests/freqai/conftest.py
+++ b/tests/freqai/conftest.py
@@ -1,3 +1,4 @@
+import platform
 from copy import deepcopy
 from pathlib import Path
 from typing import Any, Dict
@@ -14,6 +15,11 @@ from freqtrade.resolvers.freqaimodel_resolver import FreqaiModelResolver
 from tests.conftest import get_patched_exchange
 
 
+def is_mac() -> bool:
+    machine = platform.system()
+    return "Darwin" in machine
+
+
 @pytest.fixture(scope="function")
 def freqai_conf(default_conf, tmpdir):
     freqaiconf = deepcopy(default_conf)
@@ -36,6 +42,7 @@ def freqai_conf(default_conf, tmpdir):
                 "identifier": "uniqe-id100",
                 "live_trained_timestamp": 0,
                 "data_kitchen_thread_count": 2,
+                "activate_tensorboard": False,
                 "feature_parameters": {
                     "include_timeframes": ["5m"],
                     "include_corr_pairlist": ["ADA/BTC"],
diff --git a/tests/freqai/test_freqai_datakitchen.py b/tests/freqai/test_freqai_datakitchen.py
index 3f0fc697d..13dc6b4b0 100644
--- a/tests/freqai/test_freqai_datakitchen.py
+++ b/tests/freqai/test_freqai_datakitchen.py
@@ -12,6 +12,7 @@ from freqtrade.freqai.data_kitchen import FreqaiDataKitchen
 from tests.conftest import get_patched_exchange, log_has_re
 from tests.freqai.conftest import (get_patched_data_kitchen, get_patched_freqai_strategy,
                                    make_data_dictionary, make_unfiltered_dataframe)
+from tests.freqai.test_freqai_interface import is_mac
 
 
 @pytest.mark.parametrize(
@@ -173,6 +174,9 @@ def test_get_full_model_path(mocker, freqai_conf, model):
     freqai_conf.update({"timerange": "20180110-20180130"})
     freqai_conf.update({"strategy": "freqai_test_strat"})
 
+    if is_mac():
+        pytest.skip("Mac is confused during this test for unknown reasons")
+
     strategy = get_patched_freqai_strategy(mocker, freqai_conf)
     exchange = get_patched_exchange(mocker, freqai_conf)
     strategy.dp = DataProvider(freqai_conf, exchange)
@@ -188,7 +192,7 @@ def test_get_full_model_path(mocker, freqai_conf, model):
 
     data_load_timerange = TimeRange.parse_timerange("20180110-20180130")
     new_timerange = TimeRange.parse_timerange("20180120-20180130")
-
+    freqai.dk.set_paths('ADA/BTC', None)
     freqai.extract_data_and_train_model(
         new_timerange, "ADA/BTC", strategy, freqai.dk, data_load_timerange)
 
diff --git a/tests/freqai/test_freqai_interface.py b/tests/freqai/test_freqai_interface.py
index 7346191db..61a7b7346 100644
--- a/tests/freqai/test_freqai_interface.py
+++ b/tests/freqai/test_freqai_interface.py
@@ -15,7 +15,7 @@ from freqtrade.optimize.backtesting import Backtesting
 from freqtrade.persistence import Trade
 from freqtrade.plugins.pairlistmanager import PairListManager
 from tests.conftest import EXMS, create_mock_trades, get_patched_exchange, log_has_re
-from tests.freqai.conftest import (get_patched_freqai_strategy, make_rl_config,
+from tests.freqai.conftest import (get_patched_freqai_strategy, is_mac, make_rl_config,
                                    mock_pytorch_mlp_model_training_parameters)
 
 
@@ -28,29 +28,22 @@ def is_arm() -> bool:
     return "arm" in machine or "aarch64" in machine
 
 
-def is_mac() -> bool:
-    machine = platform.system()
-    return "Darwin" in machine
-
-
 def can_run_model(model: str) -> None:
-    if (is_arm() or is_py11()) and "Catboost" in model:
+    if is_arm() and "Catboost" in model:
         pytest.skip("CatBoost is not supported on ARM.")
 
     is_pytorch_model = 'Reinforcement' in model or 'PyTorch' in model
     if is_pytorch_model and is_mac() and not is_arm():
         pytest.skip("Reinforcement learning / PyTorch module not available on intel based Mac OS.")
 
-    if is_pytorch_model and is_py11():
-        pytest.skip("Reinforcement learning / PyTorch currently not available on python 3.11.")
-
 
 @pytest.mark.parametrize('model, pca, dbscan, float32, can_short, shuffle, buffer', [
     ('LightGBMRegressor', True, False, True, True, False, 0),
     ('XGBoostRegressor', False, True, False, True, False, 10),
     ('XGBoostRFRegressor', False, False, False, True, False, 0),
     ('CatboostRegressor', False, False, False, True, True, 0),
-    ('PyTorchMLPRegressor', False, False, False, True, False, 0),
+    ('PyTorchMLPRegressor', False, False, False, False, False, 0),
+    ('PyTorchTransformerRegressor', False, False, False, False, False, 0),
     ('ReinforcementLearner', False, True, False, True, False, 0),
     ('ReinforcementLearner_multiproc', False, False, False, True, False, 0),
     ('ReinforcementLearner_test_3ac', False, False, False, False, False, 0),
@@ -61,6 +54,11 @@ def test_extract_data_and_train_model_Standard(mocker, freqai_conf, model, pca,
                                                dbscan, float32, can_short, shuffle, buffer):
 
     can_run_model(model)
+
+    test_tb = True
+    if is_mac():
+        test_tb = False
+
     model_save_ext = 'joblib'
     freqai_conf.update({"freqaimodel": model})
     freqai_conf.update({"timerange": "20180110-20180130"})
@@ -82,10 +80,13 @@ def test_extract_data_and_train_model_Standard(mocker, freqai_conf, model, pca,
         freqai_conf["freqaimodel_path"] = str(Path(__file__).parents[1] / "freqai" / "test_models")
         freqai_conf["freqai"]["rl_config"]["drop_ohlc_from_features"] = True
 
-    if 'PyTorchMLPRegressor' in model:
+    if 'PyTorch' in model:
         model_save_ext = 'zip'
         pytorch_mlp_mtp = mock_pytorch_mlp_model_training_parameters()
         freqai_conf['freqai']['model_training_parameters'].update(pytorch_mlp_mtp)
+        if 'Transformer' in model:
+            # transformer model takes a window, unlike the MLP regressor
+            freqai_conf.update({"conv_width": 10})
 
     strategy = get_patched_freqai_strategy(mocker, freqai_conf)
     exchange = get_patched_exchange(mocker, freqai_conf)
@@ -93,6 +94,7 @@ def test_extract_data_and_train_model_Standard(mocker, freqai_conf, model, pca,
     strategy.freqai_info = freqai_conf.get("freqai", {})
     freqai = strategy.freqai
     freqai.live = True
+    freqai.activate_tensorboard = test_tb
     freqai.can_short = can_short
     freqai.dk = FreqaiDataKitchen(freqai_conf)
     freqai.dk.live = True
@@ -228,6 +230,7 @@ def test_extract_data_and_train_model_Classifiers(mocker, freqai_conf, model):
         ("XGBoostRegressor", 2, "freqai_test_strat"),
         ("CatboostRegressor", 2, "freqai_test_strat"),
         ("PyTorchMLPRegressor", 2, "freqai_test_strat"),
+        ("PyTorchTransformerRegressor", 2, "freqai_test_strat"),
         ("ReinforcementLearner", 3, "freqai_rl_test_strat"),
         ("XGBoostClassifier", 2, "freqai_test_classifier"),
         ("LightGBMClassifier", 2, "freqai_test_classifier"),
@@ -237,6 +240,9 @@ def test_extract_data_and_train_model_Classifiers(mocker, freqai_conf, model):
     )
 def test_start_backtesting(mocker, freqai_conf, model, num_files, strat, caplog):
     can_run_model(model)
+    test_tb = True
+    if is_mac():
+        test_tb = False
 
     freqai_conf.get("freqai", {}).update({"save_backtest_models": True})
     freqai_conf['runmode'] = RunMode.BACKTEST
@@ -253,9 +259,12 @@ def test_start_backtesting(mocker, freqai_conf, model, num_files, strat, caplog)
     if 'test_4ac' in model:
         freqai_conf["freqaimodel_path"] = str(Path(__file__).parents[1] / "freqai" / "test_models")
 
-    if 'PyTorchMLP' in model:
+    if 'PyTorch' in model:
         pytorch_mlp_mtp = mock_pytorch_mlp_model_training_parameters()
         freqai_conf['freqai']['model_training_parameters'].update(pytorch_mlp_mtp)
+        if 'Transformer' in model:
+            # transformer model takes a window, unlike the MLP regressor
+            freqai_conf.update({"conv_width": 10})
 
     freqai_conf.get("freqai", {}).get("feature_parameters", {}).update(
         {"indicator_periods_candles": [2]})
@@ -266,6 +275,7 @@ def test_start_backtesting(mocker, freqai_conf, model, num_files, strat, caplog)
     strategy.freqai_info = freqai_conf.get("freqai", {})
     freqai = strategy.freqai
     freqai.live = False
+    freqai.activate_tensorboard = test_tb
     freqai.dk = FreqaiDataKitchen(freqai_conf)
     timerange = TimeRange.parse_timerange("20180110-20180130")
     freqai.dd.load_all_pair_histories(timerange, freqai.dk)
@@ -277,6 +287,7 @@ def test_start_backtesting(mocker, freqai_conf, model, num_files, strat, caplog)
         df[f'%-constant_{i}'] = i
 
     metadata = {"pair": "LTC/BTC"}
+    freqai.dk.set_paths('LTC/BTC', None)
     freqai.start_backtesting(df, metadata, freqai.dk, strategy)
     model_folders = [x for x in freqai.dd.full_path.iterdir() if x.is_dir()]
 
@@ -434,6 +445,7 @@ def test_principal_component_analysis(mocker, freqai_conf):
 
     data_load_timerange = TimeRange.parse_timerange("20180110-20180130")
     new_timerange = TimeRange.parse_timerange("20180120-20180130")
+    freqai.dk.set_paths('ADA/BTC', None)
 
     freqai.extract_data_and_train_model(
         new_timerange, "ADA/BTC", strategy, freqai.dk, data_load_timerange)
@@ -467,6 +479,7 @@ def test_plot_feature_importance(mocker, freqai_conf):
 
     data_load_timerange = TimeRange.parse_timerange("20180110-20180130")
     new_timerange = TimeRange.parse_timerange("20180120-20180130")
+    freqai.dk.set_paths('ADA/BTC', None)
 
     freqai.extract_data_and_train_model(
         new_timerange, "ADA/BTC", strategy, freqai.dk, data_load_timerange)
diff --git a/tests/freqai/test_models/ReinforcementLearner_test_3ac.py b/tests/freqai/test_models/ReinforcementLearner_test_3ac.py
index c267c76a8..f77120c3c 100644
--- a/tests/freqai/test_models/ReinforcementLearner_test_3ac.py
+++ b/tests/freqai/test_models/ReinforcementLearner_test_3ac.py
@@ -18,6 +18,11 @@ class ReinforcementLearner_test_3ac(ReinforcementLearner):
         """
         User can override any function in BaseRLEnv and gym.Env. Here the user
         sets a custom reward based on profit and trade duration.
+
+        Warning!
+        This is function is a showcase of functionality designed to show as many possible
+        environment control features as possible. It is also designed to run quickly
+        on small computers. This is a benchmark, it is *not* for live production.
         """
 
         def calculate_reward(self, action: int) -> float:
diff --git a/tests/freqai/test_models/ReinforcementLearner_test_4ac.py b/tests/freqai/test_models/ReinforcementLearner_test_4ac.py
index 29e3e3b64..4fc2b0005 100644
--- a/tests/freqai/test_models/ReinforcementLearner_test_4ac.py
+++ b/tests/freqai/test_models/ReinforcementLearner_test_4ac.py
@@ -18,6 +18,11 @@ class ReinforcementLearner_test_4ac(ReinforcementLearner):
         """
         User can override any function in BaseRLEnv and gym.Env. Here the user
         sets a custom reward based on profit and trade duration.
+
+        Warning!
+        This is function is a showcase of functionality designed to show as many possible
+        environment control features as possible. It is also designed to run quickly
+        on small computers. This is a benchmark, it is *not* for live production.
         """
 
         def calculate_reward(self, action: int) -> float:
diff --git a/tests/optimize/__init__.py b/tests/optimize/__init__.py
index a3dd59004..b95764ba5 100644
--- a/tests/optimize/__init__.py
+++ b/tests/optimize/__init__.py
@@ -1,13 +1,14 @@
+from datetime import timedelta
 from typing import Dict, List, NamedTuple, Optional
 
-import arrow
 from pandas import DataFrame
 
 from freqtrade.enums import ExitType
 from freqtrade.exchange import timeframe_to_minutes
+from freqtrade.util.datetime_helpers import dt_utc
 
 
-tests_start_time = arrow.get(2018, 10, 3)
+tests_start_time = dt_utc(2018, 10, 3)
 tests_timeframe = '1h'
 
 
@@ -46,7 +47,7 @@ class BTContainer(NamedTuple):
 
 def _get_frame_time_from_offset(offset):
     minutes = offset * timeframe_to_minutes(tests_timeframe)
-    return tests_start_time.shift(minutes=minutes).datetime
+    return tests_start_time + timedelta(minutes=minutes)
 
 
 def _build_backtest_dataframe(data):
diff --git a/tests/optimize/test_backtesting.py b/tests/optimize/test_backtesting.py
index 9dbda51b0..bef942b43 100644
--- a/tests/optimize/test_backtesting.py
+++ b/tests/optimize/test_backtesting.py
@@ -9,7 +9,6 @@ from unittest.mock import MagicMock, PropertyMock
 import numpy as np
 import pandas as pd
 import pytest
-from arrow import Arrow
 
 from freqtrade import constants
 from freqtrade.commands.optimize_commands import setup_optimize_configuration, start_backtesting
@@ -26,6 +25,7 @@ from freqtrade.optimize.backtest_caching import get_strategy_run_id
 from freqtrade.optimize.backtesting import Backtesting
 from freqtrade.persistence import LocalTrade, Trade
 from freqtrade.resolvers import StrategyResolver
+from freqtrade.util.datetime_helpers import dt_utc
 from tests.conftest import (CURRENT_TEST_STRATEGY, EXMS, get_args, log_has, log_has_re,
                             patch_exchange, patched_configuration_load_config_file)
 
@@ -346,7 +346,7 @@ def test_backtest_abort(default_conf, mocker, testdatadir) -> None:
 
 def test_backtesting_start(default_conf, mocker, caplog) -> None:
     def get_timerange(input1):
-        return Arrow(2017, 11, 14, 21, 17), Arrow(2017, 11, 14, 22, 59)
+        return dt_utc(2017, 11, 14, 21, 17), dt_utc(2017, 11, 14, 22, 59)
 
     mocker.patch('freqtrade.data.history.get_timerange', get_timerange)
     patch_exchange(mocker)
@@ -354,7 +354,7 @@ def test_backtesting_start(default_conf, mocker, caplog) -> None:
     mocker.patch('freqtrade.optimize.backtesting.generate_backtest_stats')
     mocker.patch('freqtrade.optimize.backtesting.show_backtest_results')
     sbs = mocker.patch('freqtrade.optimize.backtesting.store_backtest_stats')
-    sbc = mocker.patch('freqtrade.optimize.backtesting.store_backtest_signal_candles')
+    sbc = mocker.patch('freqtrade.optimize.backtesting.store_backtest_analysis_results')
     mocker.patch('freqtrade.plugins.pairlistmanager.PairListManager.whitelist',
                  PropertyMock(return_value=['UNITTEST/BTC']))
 
@@ -385,7 +385,7 @@ def test_backtesting_start(default_conf, mocker, caplog) -> None:
 
 def test_backtesting_start_no_data(default_conf, mocker, caplog, testdatadir) -> None:
     def get_timerange(input1):
-        return Arrow(2017, 11, 14, 21, 17), Arrow(2017, 11, 14, 22, 59)
+        return dt_utc(2017, 11, 14, 21, 17), dt_utc(2017, 11, 14, 22, 59)
 
     mocker.patch('freqtrade.data.history.history_utils.load_pair_history',
                  MagicMock(return_value=pd.DataFrame()))
@@ -710,11 +710,11 @@ def test_backtest_one(default_conf, fee, mocker, testdatadir) -> None:
          'stake_amount': [0.001, 0.001],
          'max_stake_amount': [0.001, 0.001],
          'amount': [0.00957442, 0.0097064],
-         'open_date': pd.to_datetime([Arrow(2018, 1, 29, 18, 40, 0).datetime,
-                                      Arrow(2018, 1, 30, 3, 30, 0).datetime], utc=True
+         'open_date': pd.to_datetime([dt_utc(2018, 1, 29, 18, 40, 0),
+                                      dt_utc(2018, 1, 30, 3, 30, 0)], utc=True
                                      ),
-         'close_date': pd.to_datetime([Arrow(2018, 1, 29, 22, 35, 0).datetime,
-                                       Arrow(2018, 1, 30, 4, 10, 0).datetime], utc=True),
+         'close_date': pd.to_datetime([dt_utc(2018, 1, 29, 22, 35, 0),
+                                       dt_utc(2018, 1, 30, 4, 10, 0)], utc=True),
          'open_rate': [0.104445, 0.10302485],
          'close_rate': [0.104969, 0.103541],
          'fee_open': [0.0025, 0.0025],
diff --git a/tests/optimize/test_backtesting_adjust_position.py b/tests/optimize/test_backtesting_adjust_position.py
index 0d57ff89a..ce26e836e 100644
--- a/tests/optimize/test_backtesting_adjust_position.py
+++ b/tests/optimize/test_backtesting_adjust_position.py
@@ -5,13 +5,13 @@ from unittest.mock import MagicMock
 
 import pandas as pd
 import pytest
-from arrow import Arrow
 
 from freqtrade.configuration import TimeRange
 from freqtrade.data import history
 from freqtrade.data.history import get_timerange
 from freqtrade.enums import ExitType, TradingMode
 from freqtrade.optimize.backtesting import Backtesting
+from freqtrade.util.datetime_helpers import dt_utc
 from tests.conftest import EXMS, patch_exchange
 
 
@@ -52,11 +52,11 @@ def test_backtest_position_adjustment(default_conf, fee, mocker, testdatadir) ->
          'stake_amount': [500.0, 100.0],
          'max_stake_amount': [500.0, 100],
          'amount': [4806.87657523, 970.63960782],
-         'open_date': pd.to_datetime([Arrow(2018, 1, 29, 18, 40, 0).datetime,
-                                      Arrow(2018, 1, 30, 3, 30, 0).datetime], utc=True
+         'open_date': pd.to_datetime([dt_utc(2018, 1, 29, 18, 40, 0),
+                                      dt_utc(2018, 1, 30, 3, 30, 0)], utc=True
                                      ),
-         'close_date': pd.to_datetime([Arrow(2018, 1, 29, 22, 00, 0).datetime,
-                                       Arrow(2018, 1, 30, 4, 10, 0).datetime], utc=True),
+         'close_date': pd.to_datetime([dt_utc(2018, 1, 29, 22, 00, 0),
+                                       dt_utc(2018, 1, 30, 4, 10, 0)], utc=True),
          'open_rate': [0.10401764894444211, 0.10302485],
          'close_rate': [0.10453904066847439, 0.103541],
          'fee_open': [0.0025, 0.0025],
diff --git a/tests/optimize/test_hyperopt.py b/tests/optimize/test_hyperopt.py
index 786720030..ed5eeafd6 100644
--- a/tests/optimize/test_hyperopt.py
+++ b/tests/optimize/test_hyperopt.py
@@ -6,7 +6,6 @@ from unittest.mock import ANY, MagicMock, PropertyMock
 
 import pandas as pd
 import pytest
-from arrow import Arrow
 from filelock import Timeout
 from skopt.space import Integer
 
@@ -20,6 +19,7 @@ from freqtrade.optimize.hyperopt_tools import HyperoptTools
 from freqtrade.optimize.optimize_reports import generate_strategy_stats
 from freqtrade.optimize.space import SKDecimal
 from freqtrade.strategy import IntParameter
+from freqtrade.util import dt_utc
 from tests.conftest import (CURRENT_TEST_STRATEGY, EXMS, get_args, get_markets, log_has, log_has_re,
                             patch_exchange, patched_configuration_load_config_file)
 
@@ -349,14 +349,14 @@ def test_hyperopt_format_results(hyperopt):
                                           "UNITTEST/BTC", "UNITTEST/BTC"],
                                  "profit_ratio": [0.003312, 0.010801, 0.013803, 0.002780],
                                  "profit_abs": [0.000003, 0.000011, 0.000014, 0.000003],
-                                 "open_date": [Arrow(2017, 11, 14, 19, 32, 00).datetime,
-                                               Arrow(2017, 11, 14, 21, 36, 00).datetime,
-                                               Arrow(2017, 11, 14, 22, 12, 00).datetime,
-                                               Arrow(2017, 11, 14, 22, 44, 00).datetime],
-                                 "close_date": [Arrow(2017, 11, 14, 21, 35, 00).datetime,
-                                                Arrow(2017, 11, 14, 22, 10, 00).datetime,
-                                                Arrow(2017, 11, 14, 22, 43, 00).datetime,
-                                                Arrow(2017, 11, 14, 22, 58, 00).datetime],
+                                 "open_date": [dt_utc(2017, 11, 14, 19, 32, 00),
+                                               dt_utc(2017, 11, 14, 21, 36, 00),
+                                               dt_utc(2017, 11, 14, 22, 12, 00),
+                                               dt_utc(2017, 11, 14, 22, 44, 00)],
+                                 "close_date": [dt_utc(2017, 11, 14, 21, 35, 00),
+                                                dt_utc(2017, 11, 14, 22, 10, 00),
+                                                dt_utc(2017, 11, 14, 22, 43, 00),
+                                                dt_utc(2017, 11, 14, 22, 58, 00)],
                                  "open_rate": [0.002543, 0.003003, 0.003089, 0.003214],
                                  "close_rate": [0.002546, 0.003014, 0.003103, 0.003217],
                                  "trade_duration": [123, 34, 31, 14],
@@ -379,8 +379,8 @@ def test_hyperopt_format_results(hyperopt):
         'backtest_end_time': 1619718665,
     }
     results_metrics = generate_strategy_stats(['XRP/BTC'], '', bt_result,
-                                              Arrow(2017, 11, 14, 19, 32, 00),
-                                              Arrow(2017, 12, 14, 19, 32, 00), market_change=0)
+                                              dt_utc(2017, 11, 14, 19, 32, 00),
+                                              dt_utc(2017, 12, 14, 19, 32, 00), market_change=0)
 
     results_explanation = HyperoptTools.format_results_explanation_string(results_metrics, 'BTC')
     total_profit = results_metrics['profit_total_abs']
@@ -423,14 +423,14 @@ def test_generate_optimizer(mocker, hyperopt_conf) -> None:
                                           "UNITTEST/BTC", "UNITTEST/BTC"],
                                  "profit_ratio": [0.003312, 0.010801, 0.013803, 0.002780],
                                  "profit_abs": [0.000003, 0.000011, 0.000014, 0.000003],
-                                 "open_date": [Arrow(2017, 11, 14, 19, 32, 00).datetime,
-                                               Arrow(2017, 11, 14, 21, 36, 00).datetime,
-                                               Arrow(2017, 11, 14, 22, 12, 00).datetime,
-                                               Arrow(2017, 11, 14, 22, 44, 00).datetime],
-                                 "close_date": [Arrow(2017, 11, 14, 21, 35, 00).datetime,
-                                                Arrow(2017, 11, 14, 22, 10, 00).datetime,
-                                                Arrow(2017, 11, 14, 22, 43, 00).datetime,
-                                                Arrow(2017, 11, 14, 22, 58, 00).datetime],
+                                 "open_date": [dt_utc(2017, 11, 14, 19, 32, 00),
+                                               dt_utc(2017, 11, 14, 21, 36, 00),
+                                               dt_utc(2017, 11, 14, 22, 12, 00),
+                                               dt_utc(2017, 11, 14, 22, 44, 00)],
+                                 "close_date": [dt_utc(2017, 11, 14, 21, 35, 00),
+                                                dt_utc(2017, 11, 14, 22, 10, 00),
+                                                dt_utc(2017, 11, 14, 22, 43, 00),
+                                                dt_utc(2017, 11, 14, 22, 58, 00)],
                                  "open_rate": [0.002543, 0.003003, 0.003089, 0.003214],
                                  "close_rate": [0.002546, 0.003014, 0.003103, 0.003217],
                                  "trade_duration": [123, 34, 31, 14],
@@ -453,7 +453,7 @@ def test_generate_optimizer(mocker, hyperopt_conf) -> None:
 
     mocker.patch('freqtrade.optimize.hyperopt.Backtesting.backtest', return_value=backtest_result)
     mocker.patch('freqtrade.optimize.hyperopt.get_timerange',
-                 return_value=(Arrow(2017, 12, 10), Arrow(2017, 12, 13)))
+                 return_value=(dt_utc(2017, 12, 10), dt_utc(2017, 12, 13)))
     patch_exchange(mocker)
     mocker.patch.object(Path, 'open')
     mocker.patch('freqtrade.configuration.config_validation.validate_config_schema')
@@ -513,8 +513,8 @@ def test_generate_optimizer(mocker, hyperopt_conf) -> None:
     }
 
     hyperopt = Hyperopt(hyperopt_conf)
-    hyperopt.min_date = Arrow(2017, 12, 10)
-    hyperopt.max_date = Arrow(2017, 12, 13)
+    hyperopt.min_date = dt_utc(2017, 12, 10)
+    hyperopt.max_date = dt_utc(2017, 12, 13)
     hyperopt.init_spaces()
     generate_optimizer_value = hyperopt.generate_optimizer(list(optimizer_param.values()))
     assert generate_optimizer_value == response_expected
diff --git a/tests/optimize/test_optimize_reports.py b/tests/optimize/test_optimize_reports.py
index 6428177c5..82e8a46fb 100644
--- a/tests/optimize/test_optimize_reports.py
+++ b/tests/optimize/test_optimize_reports.py
@@ -6,7 +6,6 @@ from shutil import copyfile
 import joblib
 import pandas as pd
 import pytest
-from arrow import Arrow
 
 from freqtrade.configuration import TimeRange
 from freqtrade.constants import BACKTEST_BREAKDOWNS, DATETIME_PRINT_FORMAT, LAST_BT_RESULT_FN
@@ -21,10 +20,12 @@ from freqtrade.optimize.optimize_reports import (_get_resample_from_period, gene
                                                  generate_periodic_breakdown_stats,
                                                  generate_strategy_comparison,
                                                  generate_trading_stats, show_sorted_pairlist,
-                                                 store_backtest_signal_candles,
+                                                 store_backtest_analysis_results,
                                                  store_backtest_stats, text_table_bt_results,
                                                  text_table_exit_reason, text_table_strategy)
 from freqtrade.resolvers.strategy_resolver import StrategyResolver
+from freqtrade.util import dt_ts
+from freqtrade.util.datetime_helpers import dt_from_ts, dt_utc
 from tests.conftest import CURRENT_TEST_STRATEGY
 from tests.data.test_history import _clean_test_file
 
@@ -80,14 +81,14 @@ def test_generate_backtest_stats(default_conf, testdatadir, tmpdir):
                                           "UNITTEST/BTC", "UNITTEST/BTC"],
                                  "profit_ratio": [0.003312, 0.010801, 0.013803, 0.002780],
                                  "profit_abs": [0.000003, 0.000011, 0.000014, 0.000003],
-                                 "open_date": [Arrow(2017, 11, 14, 19, 32, 00).datetime,
-                                               Arrow(2017, 11, 14, 21, 36, 00).datetime,
-                                               Arrow(2017, 11, 14, 22, 12, 00).datetime,
-                                               Arrow(2017, 11, 14, 22, 44, 00).datetime],
-                                 "close_date": [Arrow(2017, 11, 14, 21, 35, 00).datetime,
-                                                Arrow(2017, 11, 14, 22, 10, 00).datetime,
-                                                Arrow(2017, 11, 14, 22, 43, 00).datetime,
-                                                Arrow(2017, 11, 14, 22, 58, 00).datetime],
+                                 "open_date": [dt_utc(2017, 11, 14, 19, 32, 00),
+                                               dt_utc(2017, 11, 14, 21, 36, 00),
+                                               dt_utc(2017, 11, 14, 22, 12, 00),
+                                               dt_utc(2017, 11, 14, 22, 44, 00)],
+                                 "close_date": [dt_utc(2017, 11, 14, 21, 35, 00),
+                                                dt_utc(2017, 11, 14, 22, 10, 00),
+                                                dt_utc(2017, 11, 14, 22, 43, 00),
+                                                dt_utc(2017, 11, 14, 22, 58, 00)],
                                  "open_rate": [0.002543, 0.003003, 0.003089, 0.003214],
                                  "close_rate": [0.002546, 0.003014, 0.003103, 0.003217],
                                  "trade_duration": [123, 34, 31, 14],
@@ -106,14 +107,14 @@ def test_generate_backtest_stats(default_conf, testdatadir, tmpdir):
         'canceled_trade_entries': 0,
         'canceled_entry_orders': 0,
         'replaced_entry_orders': 0,
-        'backtest_start_time': Arrow.utcnow().int_timestamp,
-        'backtest_end_time': Arrow.utcnow().int_timestamp,
+        'backtest_start_time': dt_ts() // 1000,
+        'backtest_end_time': dt_ts() // 1000,
         'run_id': '123',
         }
         }
     timerange = TimeRange.parse_timerange('1510688220-1510700340')
-    min_date = Arrow.fromtimestamp(1510688220)
-    max_date = Arrow.fromtimestamp(1510700340)
+    min_date = dt_from_ts(1510688220)
+    max_date = dt_from_ts(1510700340)
     btdata = history.load_data(testdatadir, '1m', ['UNITTEST/BTC'], timerange=timerange,
                                fill_up_missing=True)
 
@@ -135,14 +136,14 @@ def test_generate_backtest_stats(default_conf, testdatadir, tmpdir):
             {"pair": ["UNITTEST/BTC", "UNITTEST/BTC", "UNITTEST/BTC", "UNITTEST/BTC"],
              "profit_ratio": [0.003312, 0.010801, -0.013803, 0.002780],
              "profit_abs": [0.000003, 0.000011, -0.000014, 0.000003],
-             "open_date": [Arrow(2017, 11, 14, 19, 32, 00).datetime,
-                           Arrow(2017, 11, 14, 21, 36, 00).datetime,
-                           Arrow(2017, 11, 14, 22, 12, 00).datetime,
-                           Arrow(2017, 11, 14, 22, 44, 00).datetime],
-             "close_date": [Arrow(2017, 11, 14, 21, 35, 00).datetime,
-                            Arrow(2017, 11, 14, 22, 10, 00).datetime,
-                            Arrow(2017, 11, 14, 22, 43, 00).datetime,
-                            Arrow(2017, 11, 14, 22, 58, 00).datetime],
+             "open_date": [dt_utc(2017, 11, 14, 19, 32, 00),
+                           dt_utc(2017, 11, 14, 21, 36, 00),
+                           dt_utc(2017, 11, 14, 22, 12, 00),
+                           dt_utc(2017, 11, 14, 22, 44, 00)],
+             "close_date": [dt_utc(2017, 11, 14, 21, 35, 00),
+                            dt_utc(2017, 11, 14, 22, 10, 00),
+                            dt_utc(2017, 11, 14, 22, 43, 00),
+                            dt_utc(2017, 11, 14, 22, 58, 00)],
              "open_rate": [0.002543, 0.003003, 0.003089, 0.003214],
              "close_rate": [0.002546, 0.003014, 0.0032903, 0.003217],
              "trade_duration": [123, 34, 31, 14],
@@ -161,8 +162,8 @@ def test_generate_backtest_stats(default_conf, testdatadir, tmpdir):
         'canceled_trade_entries': 0,
         'canceled_entry_orders': 0,
         'replaced_entry_orders': 0,
-        'backtest_start_time': Arrow.utcnow().int_timestamp,
-        'backtest_end_time': Arrow.utcnow().int_timestamp,
+        'backtest_start_time': dt_ts() // 1000,
+        'backtest_end_time': dt_ts() // 1000,
         'run_id': '124',
         }
     }
@@ -232,17 +233,17 @@ def test_store_backtest_candles(testdatadir, mocker):
     candle_dict = {'DefStrat': {'UNITTEST/BTC': pd.DataFrame()}}
 
     # mock directory exporting
-    store_backtest_signal_candles(testdatadir, candle_dict, '2022_01_01_15_05_13')
+    store_backtest_analysis_results(testdatadir, candle_dict, {}, '2022_01_01_15_05_13')
 
-    assert dump_mock.call_count == 1
+    assert dump_mock.call_count == 2
     assert isinstance(dump_mock.call_args_list[0][0][0], Path)
     assert str(dump_mock.call_args_list[0][0][0]).endswith('_signals.pkl')
 
     dump_mock.reset_mock()
     # mock file exporting
     filename = Path(testdatadir / 'testresult')
-    store_backtest_signal_candles(filename, candle_dict, '2022_01_01_15_05_13')
-    assert dump_mock.call_count == 1
+    store_backtest_analysis_results(filename, candle_dict, {}, '2022_01_01_15_05_13')
+    assert dump_mock.call_count == 2
     assert isinstance(dump_mock.call_args_list[0][0][0], Path)
     # result will be testdatadir / testresult-<timestamp>_signals.pkl
     assert str(dump_mock.call_args_list[0][0][0]).endswith('_signals.pkl')
@@ -254,10 +255,11 @@ def test_write_read_backtest_candles(tmpdir):
     candle_dict = {'DefStrat': {'UNITTEST/BTC': pd.DataFrame()}}
 
     # test directory exporting
-    stored_file = store_backtest_signal_candles(Path(tmpdir), candle_dict, '2022_01_01_15_05_13')
-    scp = stored_file.open("rb")
-    pickled_signal_candles = joblib.load(scp)
-    scp.close()
+    sample_date = '2022_01_01_15_05_13'
+    store_backtest_analysis_results(Path(tmpdir), candle_dict, {}, sample_date)
+    stored_file = Path(tmpdir / f'backtest-result-{sample_date}_signals.pkl')
+    with stored_file.open("rb") as scp:
+        pickled_signal_candles = joblib.load(scp)
 
     assert pickled_signal_candles.keys() == candle_dict.keys()
     assert pickled_signal_candles['DefStrat'].keys() == pickled_signal_candles['DefStrat'].keys()
@@ -268,10 +270,10 @@ def test_write_read_backtest_candles(tmpdir):
 
     # test file exporting
     filename = Path(tmpdir / 'testresult')
-    stored_file = store_backtest_signal_candles(filename, candle_dict, '2022_01_01_15_05_13')
-    scp = stored_file.open("rb")
-    pickled_signal_candles = joblib.load(scp)
-    scp.close()
+    store_backtest_analysis_results(filename, candle_dict, {}, sample_date)
+    stored_file = Path(tmpdir / f'testresult-{sample_date}_signals.pkl')
+    with stored_file.open("rb") as scp:
+        pickled_signal_candles = joblib.load(scp)
 
     assert pickled_signal_candles.keys() == candle_dict.keys()
     assert pickled_signal_candles['DefStrat'].keys() == pickled_signal_candles['DefStrat'].keys()
diff --git a/tests/persistence/test_migrations.py b/tests/persistence/test_migrations.py
index 854d39994..13b3f89bf 100644
--- a/tests/persistence/test_migrations.py
+++ b/tests/persistence/test_migrations.py
@@ -1,15 +1,18 @@
 # pragma pylint: disable=missing-docstring, C0103
 import logging
+from importlib import import_module
 from pathlib import Path
 from unittest.mock import MagicMock
 
 import pytest
 from sqlalchemy import create_engine, select, text
+from sqlalchemy.schema import CreateTable
 
 from freqtrade.constants import DEFAULT_DB_PROD_URL
 from freqtrade.enums import TradingMode
 from freqtrade.exceptions import OperationalException
 from freqtrade.persistence import Trade, init_db
+from freqtrade.persistence.base import ModelBase
 from freqtrade.persistence.migrations import get_last_sequence_ids, set_sequence_ids
 from freqtrade.persistence.models import PairLock
 from tests.conftest import log_has
@@ -411,3 +414,14 @@ def test_migrate_pairlocks(mocker, default_conf, fee, caplog):
     assert len(pairlocks) == 1
     pairlocks[0].pair == 'ETH/BTC'
     pairlocks[0].side == '*'
+
+
+@pytest.mark.parametrize('dialect', [
+    'sqlite', 'postgresql', 'mysql', 'oracle', 'mssql',
+    ])
+def test_create_table_compiles(dialect):
+
+    dialect_mod = import_module(f"sqlalchemy.dialects.{dialect}")
+    for table in ModelBase.metadata.tables.values():
+        create_sql = str(CreateTable(table).compile(dialect=dialect_mod.dialect()))
+        assert 'CREATE TABLE' in create_sql
diff --git a/tests/persistence/test_persistence.py b/tests/persistence/test_persistence.py
index 948973ed5..4aa3b1e96 100644
--- a/tests/persistence/test_persistence.py
+++ b/tests/persistence/test_persistence.py
@@ -2,7 +2,6 @@
 from datetime import datetime, timedelta, timezone
 from types import FunctionType
 
-import arrow
 import pytest
 from sqlalchemy import select
 
@@ -10,6 +9,7 @@ from freqtrade.constants import CUSTOM_TAG_MAX_LENGTH, DATETIME_PRINT_FORMAT
 from freqtrade.enums import TradingMode
 from freqtrade.exceptions import DependencyException
 from freqtrade.persistence import LocalTrade, Order, Trade, init_db
+from freqtrade.util import dt_now
 from tests.conftest import create_mock_trades, create_mock_trades_with_leverage, log_has, log_has_re
 
 
@@ -27,7 +27,7 @@ def test_enter_exit_side(fee, is_short):
         open_rate=0.01,
         amount=5,
         is_open=True,
-        open_date=arrow.utcnow().datetime,
+        open_date=dt_now(),
         fee_open=fee.return_value,
         fee_close=fee.return_value,
         exchange='binance',
@@ -49,7 +49,7 @@ def test_set_stop_loss_liquidation(fee):
         open_rate=2.0,
         amount=30.0,
         is_open=True,
-        open_date=arrow.utcnow().datetime,
+        open_date=dt_now(),
         fee_open=fee.return_value,
         fee_close=fee.return_value,
         exchange='binance',
@@ -239,7 +239,7 @@ def test_interest(fee, exchange, is_short, lev, minutes, rate, interest,
         stake_amount=20.0,
         amount=30.0,
         open_rate=2.0,
-        open_date=datetime.utcnow() - timedelta(minutes=minutes),
+        open_date=datetime.now(timezone.utc) - timedelta(minutes=minutes),
         fee_open=fee.return_value,
         fee_close=fee.return_value,
         exchange=exchange,
@@ -329,7 +329,7 @@ def test_borrowed(fee, is_short, lev, borrowed, trading_mode):
         open_rate=2.0,
         amount=30.0,
         is_open=True,
-        open_date=arrow.utcnow().datetime,
+        open_date=dt_now(),
         fee_open=fee.return_value,
         fee_close=fee.return_value,
         exchange='binance',
@@ -428,7 +428,7 @@ def test_update_limit_order(fee, caplog, limit_buy_order_usdt, limit_sell_order_
         open_rate=open_rate,
         amount=30.0,
         is_open=True,
-        open_date=arrow.utcnow().datetime,
+        open_date=dt_now(),
         fee_open=fee.return_value,
         fee_close=fee.return_value,
         exchange='binance',
@@ -485,7 +485,7 @@ def test_update_market_order(market_buy_order_usdt, market_sell_order_usdt, fee,
         is_open=True,
         fee_open=fee.return_value,
         fee_close=fee.return_value,
-        open_date=arrow.utcnow().datetime,
+        open_date=dt_now(),
         exchange='binance',
         trading_mode=margin,
         leverage=1.0,
@@ -635,7 +635,7 @@ def test_trade_close(fee):
     assert pytest.approx(trade.close_profit) == 0.094513715
     assert trade.close_date is not None
 
-    new_date = arrow.Arrow(2020, 2, 2, 15, 6, 1).datetime,
+    new_date = datetime(2020, 2, 2, 15, 6, 1),
     assert trade.close_date != new_date
     # Close should NOT update close_date if the trade has been closed already
     assert trade.is_open is False
@@ -1326,7 +1326,7 @@ def test_to_json(fee):
         amount_requested=123.0,
         fee_open=fee.return_value,
         fee_close=fee.return_value,
-        open_date=arrow.utcnow().shift(hours=-2).datetime,
+        open_date=dt_now() - timedelta(hours=2),
         open_rate=0.123,
         exchange='binance',
         enter_tag=None,
@@ -1411,8 +1411,8 @@ def test_to_json(fee):
         amount_requested=101.0,
         fee_open=fee.return_value,
         fee_close=fee.return_value,
-        open_date=arrow.utcnow().shift(hours=-2).datetime,
-        close_date=arrow.utcnow().shift(hours=-1).datetime,
+        open_date=dt_now() - timedelta(hours=2),
+        close_date=dt_now() - timedelta(hours=1),
         open_rate=0.123,
         close_rate=0.125,
         enter_tag='buys_signal_001',
@@ -1496,7 +1496,7 @@ def test_stoploss_reinitialization(default_conf, fee):
         pair='ADA/USDT',
         stake_amount=30.0,
         fee_open=fee.return_value,
-        open_date=arrow.utcnow().shift(hours=-2).datetime,
+        open_date=dt_now() - timedelta(hours=2),
         amount=30.0,
         fee_close=fee.return_value,
         exchange='binance',
@@ -1557,7 +1557,7 @@ def test_stoploss_reinitialization_leverage(default_conf, fee):
         pair='ADA/USDT',
         stake_amount=30.0,
         fee_open=fee.return_value,
-        open_date=arrow.utcnow().shift(hours=-2).datetime,
+        open_date=dt_now() - timedelta(hours=2),
         amount=30.0,
         fee_close=fee.return_value,
         exchange='binance',
@@ -1619,7 +1619,7 @@ def test_stoploss_reinitialization_short(default_conf, fee):
         pair='ADA/USDT',
         stake_amount=0.001,
         fee_open=fee.return_value,
-        open_date=arrow.utcnow().shift(hours=-2).datetime,
+        open_date=dt_now() - timedelta(hours=2),
         amount=10,
         fee_close=fee.return_value,
         exchange='binance',
@@ -1678,7 +1678,7 @@ def test_update_fee(fee):
         pair='ADA/USDT',
         stake_amount=30.0,
         fee_open=fee.return_value,
-        open_date=arrow.utcnow().shift(hours=-2).datetime,
+        open_date=dt_now() - timedelta(hours=2),
         amount=30.0,
         fee_close=fee.return_value,
         exchange='binance',
@@ -1717,7 +1717,7 @@ def test_fee_updated(fee):
         pair='ADA/USDT',
         stake_amount=30.0,
         fee_open=fee.return_value,
-        open_date=arrow.utcnow().shift(hours=-2).datetime,
+        open_date=dt_now() - timedelta(hours=2),
         amount=30.0,
         fee_close=fee.return_value,
         exchange='binance',
@@ -2063,7 +2063,7 @@ def test_trade_truncates_string_fields():
         stake_amount=20.0,
         amount=30.0,
         open_rate=2.0,
-        open_date=datetime.utcnow() - timedelta(minutes=20),
+        open_date=datetime.now(timezone.utc) - timedelta(minutes=20),
         fee_open=0.001,
         fee_close=0.001,
         exchange='binance',
@@ -2092,7 +2092,7 @@ def test_recalc_trade_from_orders(fee):
     trade = Trade(
         pair='ADA/USDT',
         stake_amount=o1_cost,
-        open_date=arrow.utcnow().shift(hours=-2).datetime,
+        open_date=dt_now() - timedelta(hours=2),
         amount=o1_amount,
         fee_open=fee.return_value,
         fee_close=fee.return_value,
@@ -2167,8 +2167,8 @@ def test_recalc_trade_from_orders(fee):
         filled=o2_amount,
         remaining=0,
         cost=o2_cost,
-        order_date=arrow.utcnow().shift(hours=-1).datetime,
-        order_filled_date=arrow.utcnow().shift(hours=-1).datetime,
+        order_date=dt_now() - timedelta(hours=1),
+        order_filled_date=dt_now() - timedelta(hours=1),
     )
     trade.orders.append(order2)
     trade.recalc_trade_from_orders()
@@ -2201,8 +2201,8 @@ def test_recalc_trade_from_orders(fee):
         filled=o3_amount,
         remaining=0,
         cost=o3_cost,
-        order_date=arrow.utcnow().shift(hours=-1).datetime,
-        order_filled_date=arrow.utcnow().shift(hours=-1).datetime,
+        order_date=dt_now() - timedelta(hours=1),
+        order_filled_date=dt_now() - timedelta(hours=1),
     )
     trade.orders.append(order3)
     trade.recalc_trade_from_orders()
@@ -2257,7 +2257,7 @@ def test_recalc_trade_from_orders_ignores_bad_orders(fee, is_short):
     trade = Trade(
         pair='ADA/USDT',
         stake_amount=o1_cost,
-        open_date=arrow.utcnow().shift(hours=-2).datetime,
+        open_date=dt_now() - timedelta(hours=2),
         amount=o1_amount,
         fee_open=fee.return_value,
         fee_close=fee.return_value,
@@ -2309,8 +2309,8 @@ def test_recalc_trade_from_orders_ignores_bad_orders(fee, is_short):
         filled=o1_amount,
         remaining=0,
         cost=o1_cost,
-        order_date=arrow.utcnow().shift(hours=-1).datetime,
-        order_filled_date=arrow.utcnow().shift(hours=-1).datetime,
+        order_date=dt_now() - timedelta(hours=1),
+        order_filled_date=dt_now() - timedelta(hours=1),
     )
     trade.orders.append(order2)
     trade.recalc_trade_from_orders()
@@ -2337,8 +2337,8 @@ def test_recalc_trade_from_orders_ignores_bad_orders(fee, is_short):
         filled=0,
         remaining=4,
         cost=5,
-        order_date=arrow.utcnow().shift(hours=-1).datetime,
-        order_filled_date=arrow.utcnow().shift(hours=-1).datetime,
+        order_date=dt_now() - timedelta(hours=1),
+        order_filled_date=dt_now() - timedelta(hours=1),
     )
     trade.orders.append(order3)
     trade.recalc_trade_from_orders()
@@ -2364,8 +2364,8 @@ def test_recalc_trade_from_orders_ignores_bad_orders(fee, is_short):
         filled=o1_amount,
         remaining=0,
         cost=o1_cost,
-        order_date=arrow.utcnow().shift(hours=-1).datetime,
-        order_filled_date=arrow.utcnow().shift(hours=-1).datetime,
+        order_date=dt_now() - timedelta(hours=1),
+        order_filled_date=dt_now() - timedelta(hours=1),
     )
     trade.orders.append(order4)
     trade.recalc_trade_from_orders()
@@ -2481,7 +2481,7 @@ def test_select_filled_orders(fee):
 
 
 @pytest.mark.usefixtures("init_persistence")
-def test_order_to_ccxt(limit_buy_order_open):
+def test_order_to_ccxt(limit_buy_order_open, limit_sell_order_usdt_open):
 
     order = Order.parse_from_ccxt_object(limit_buy_order_open, 'mocked', 'buy')
     order.ft_trade_id = 1
@@ -2495,11 +2495,23 @@ def test_order_to_ccxt(limit_buy_order_open):
     del raw_order['fee']
     del raw_order['datetime']
     del raw_order['info']
-    assert raw_order['stopPrice'] is None
-    del raw_order['stopPrice']
+    assert raw_order.get('stopPrice') is None
+    raw_order.pop('stopPrice', None)
     del limit_buy_order_open['datetime']
     assert raw_order == limit_buy_order_open
 
+    order1 = Order.parse_from_ccxt_object(limit_sell_order_usdt_open, 'mocked', 'sell')
+    order1.ft_order_side = 'stoploss'
+    order1.stop_price = order1.price * 0.9
+    order1.ft_trade_id = 1
+    order1.session.add(order1)
+    Order.session.commit()
+
+    order_resp1 = Order.order_by_id(limit_sell_order_usdt_open['id'])
+    raw_order1 = order_resp1.to_ccxt_object()
+
+    assert raw_order1.get('stopPrice') is not None
+
 
 @pytest.mark.usefixtures("init_persistence")
 @pytest.mark.parametrize('data', [
@@ -2580,7 +2592,7 @@ def test_recalc_trade_from_orders_dca(data) -> None:
         open_rate=data['orders'][0][0][2],
         amount=data['orders'][0][0][1],
         is_open=True,
-        open_date=arrow.utcnow().datetime,
+        open_date=dt_now(),
         fee_open=data['fee'],
         fee_close=data['fee'],
         exchange='binance',
@@ -2610,8 +2622,8 @@ def test_recalc_trade_from_orders_dca(data) -> None:
             filled=amount,
             remaining=0,
             cost=amount * price,
-            order_date=arrow.utcnow().shift(hours=-10 + idx).datetime,
-            order_filled_date=arrow.utcnow().shift(hours=-10 + idx).datetime,
+            order_date=dt_now() - timedelta(hours=10 + idx),
+            order_filled_date=dt_now() - timedelta(hours=10 + idx),
         )
         trade.orders.append(order_obj)
         trade.recalc_trade_from_orders()
diff --git a/tests/plugins/test_pairlocks.py b/tests/plugins/test_pairlocks.py
index 6b7112f98..6e209df60 100644
--- a/tests/plugins/test_pairlocks.py
+++ b/tests/plugins/test_pairlocks.py
@@ -1,10 +1,10 @@
 from datetime import datetime, timedelta, timezone
 
-import arrow
 import pytest
 
 from freqtrade.persistence import PairLocks
 from freqtrade.persistence.models import PairLock
+from freqtrade.util import dt_now
 
 
 @pytest.mark.parametrize('use_db', (False, True))
@@ -20,20 +20,20 @@ def test_PairLocks(use_db):
 
     pair = 'ETH/BTC'
     assert not PairLocks.is_pair_locked(pair)
-    PairLocks.lock_pair(pair, arrow.utcnow().shift(minutes=4).datetime)
+    PairLocks.lock_pair(pair, dt_now() + timedelta(minutes=4))
     # ETH/BTC locked for 4 minutes (on both sides)
     assert PairLocks.is_pair_locked(pair)
     assert PairLocks.is_pair_locked(pair, side='long')
     assert PairLocks.is_pair_locked(pair, side='short')
 
     pair = 'BNB/BTC'
-    PairLocks.lock_pair(pair, arrow.utcnow().shift(minutes=4).datetime, side='long')
+    PairLocks.lock_pair(pair, dt_now() + timedelta(minutes=4), side='long')
     assert not PairLocks.is_pair_locked(pair)
     assert PairLocks.is_pair_locked(pair, side='long')
     assert not PairLocks.is_pair_locked(pair, side='short')
 
     pair = 'BNB/USDT'
-    PairLocks.lock_pair(pair, arrow.utcnow().shift(minutes=4).datetime, side='short')
+    PairLocks.lock_pair(pair, dt_now() + timedelta(minutes=4), side='short')
     assert not PairLocks.is_pair_locked(pair)
     assert not PairLocks.is_pair_locked(pair, side='long')
     assert PairLocks.is_pair_locked(pair, side='short')
@@ -44,7 +44,7 @@ def test_PairLocks(use_db):
     # Unlocking a pair that's not locked should not raise an error
     PairLocks.unlock_pair(pair)
 
-    PairLocks.lock_pair(pair, arrow.utcnow().shift(minutes=4).datetime)
+    PairLocks.lock_pair(pair, dt_now() + timedelta(minutes=4))
     assert PairLocks.is_pair_locked(pair)
 
     # Get both locks from above
@@ -113,20 +113,20 @@ def test_PairLocks_getlongestlock(use_db):
 
     pair = 'ETH/BTC'
     assert not PairLocks.is_pair_locked(pair)
-    PairLocks.lock_pair(pair, arrow.utcnow().shift(minutes=4).datetime)
+    PairLocks.lock_pair(pair, dt_now() + timedelta(minutes=4))
     # ETH/BTC locked for 4 minutes
     assert PairLocks.is_pair_locked(pair)
     lock = PairLocks.get_pair_longest_lock(pair)
 
-    assert lock.lock_end_time.replace(tzinfo=timezone.utc) > arrow.utcnow().shift(minutes=3)
-    assert lock.lock_end_time.replace(tzinfo=timezone.utc) < arrow.utcnow().shift(minutes=14)
+    assert lock.lock_end_time.replace(tzinfo=timezone.utc) > dt_now() + timedelta(minutes=3)
+    assert lock.lock_end_time.replace(tzinfo=timezone.utc) < dt_now() + timedelta(minutes=14)
 
-    PairLocks.lock_pair(pair, arrow.utcnow().shift(minutes=15).datetime)
+    PairLocks.lock_pair(pair, dt_now() + timedelta(minutes=15))
     assert PairLocks.is_pair_locked(pair)
 
     lock = PairLocks.get_pair_longest_lock(pair)
     # Must be longer than above
-    assert lock.lock_end_time.replace(tzinfo=timezone.utc) > arrow.utcnow().shift(minutes=14)
+    assert lock.lock_end_time.replace(tzinfo=timezone.utc) > dt_now() + timedelta(minutes=14)
 
     PairLocks.reset_locks()
     PairLocks.use_db = True
@@ -143,8 +143,8 @@ def test_PairLocks_reason(use_db):
 
     assert PairLocks.use_db == use_db
 
-    PairLocks.lock_pair('XRP/USDT', arrow.utcnow().shift(minutes=4).datetime, 'TestLock1')
-    PairLocks.lock_pair('ETH/USDT', arrow.utcnow().shift(minutes=4).datetime, 'TestLock2')
+    PairLocks.lock_pair('XRP/USDT', dt_now() + timedelta(minutes=4), 'TestLock1')
+    PairLocks.lock_pair('ETH/USDT', dt_now() + timedelta(minutes=4), 'TestLock2')
 
     assert PairLocks.is_pair_locked('XRP/USDT')
     assert PairLocks.is_pair_locked('ETH/USDT')
diff --git a/tests/plugins/test_protections.py b/tests/plugins/test_protections.py
index 5e6128c73..8fe8cec6b 100644
--- a/tests/plugins/test_protections.py
+++ b/tests/plugins/test_protections.py
@@ -1,5 +1,5 @@
 import random
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 
 import pytest
 
@@ -24,8 +24,8 @@ def generate_mock_trade(pair: str, fee: float, is_open: bool,
         stake_amount=0.01,
         fee_open=fee,
         fee_close=fee,
-        open_date=datetime.utcnow() - timedelta(minutes=min_ago_open or 200),
-        close_date=datetime.utcnow() - timedelta(minutes=min_ago_close or 30),
+        open_date=datetime.now(timezone.utc) - timedelta(minutes=min_ago_open or 200),
+        close_date=datetime.now(timezone.utc) - timedelta(minutes=min_ago_close or 30),
         open_rate=open_rate,
         is_open=is_open,
         amount=0.01 / open_rate,
@@ -87,9 +87,9 @@ def test_protectionmanager(mocker, default_conf):
     for handler in freqtrade.protections._protection_handlers:
         assert handler.name in constants.AVAILABLE_PROTECTIONS
         if not handler.has_global_stop:
-            assert handler.global_stop(datetime.utcnow(), '*') is None
+            assert handler.global_stop(datetime.now(timezone.utc), '*') is None
         if not handler.has_local_stop:
-            assert handler.stop_per_pair('XRP/BTC', datetime.utcnow(), '*') is None
+            assert handler.stop_per_pair('XRP/BTC', datetime.now(timezone.utc), '*') is None
 
 
 @pytest.mark.parametrize('timeframe,expected,protconf', [
diff --git a/tests/rpc/test_rpc.py b/tests/rpc/test_rpc.py
index 5a84eaa48..405727d8c 100644
--- a/tests/rpc/test_rpc.py
+++ b/tests/rpc/test_rpc.py
@@ -261,8 +261,7 @@ def test_rpc_status_table(default_conf, ticker, fee, mocker) -> None:
     assert isnan(fiat_profit_sum)
 
 
-def test__rpc_timeunit_profit(default_conf_usdt, ticker, fee,
-                              limit_buy_order, limit_sell_order, markets, mocker) -> None:
+def test__rpc_timeunit_profit(default_conf_usdt, ticker, fee, markets, mocker) -> None:
     mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
     mocker.patch.multiple(
         EXMS,
@@ -295,7 +294,7 @@ def test__rpc_timeunit_profit(default_conf_usdt, ticker, fee,
         assert day['starting_balance'] in (pytest.approx(1062.37), pytest.approx(1066.46))
         assert day['fiat_value'] in (0.0, )
     # ensure first day is current date
-    assert str(days['data'][0]['date']) == str(datetime.utcnow().date())
+    assert str(days['data'][0]['date']) == str(datetime.now(timezone.utc).date())
 
     # Try invalid data
     with pytest.raises(RPCException, match=r'.*must be an integer greater than 0*'):
@@ -415,8 +414,8 @@ def test_rpc_trade_statistics(default_conf_usdt, ticker, fee, mocker) -> None:
     assert pytest.approx(stats['profit_all_percent_mean']) == -57.86
     assert pytest.approx(stats['profit_all_fiat']) == -85.205614098
     assert stats['trade_count'] == 7
-    assert stats['first_trade_date'] == '2 days ago'
-    assert stats['latest_trade_date'] == '17 minutes ago'
+    assert stats['first_trade_humanized'] == '2 days ago'
+    assert stats['latest_trade_humanized'] == '17 minutes ago'
     assert stats['avg_duration'] in ('0:17:40')
     assert stats['best_pair'] == 'XRP/USDT'
     assert stats['best_rate'] == 10.0
@@ -426,8 +425,8 @@ def test_rpc_trade_statistics(default_conf_usdt, ticker, fee, mocker) -> None:
                  MagicMock(side_effect=ExchangeError("Pair 'XRP/USDT' not available")))
     stats = rpc._rpc_trade_statistics(stake_currency, fiat_display_currency)
     assert stats['trade_count'] == 7
-    assert stats['first_trade_date'] == '2 days ago'
-    assert stats['latest_trade_date'] == '17 minutes ago'
+    assert stats['first_trade_humanized'] == '2 days ago'
+    assert stats['latest_trade_humanized'] == '17 minutes ago'
     assert stats['avg_duration'] in ('0:17:40')
     assert stats['best_pair'] == 'XRP/USDT'
     assert stats['best_rate'] == 10.0
@@ -546,53 +545,67 @@ def test_rpc_balance_handle(default_conf, mocker, tickers):
             'free': 10.0,
             'balance': 12.0,
             'used': 2.0,
+            'bot_owned': 9.9,  # available stake - reducing by reserved amount
             'est_stake': 10.0,  # In futures mode, "free" is used here.
+            'est_stake_bot': 9.9,
             'stake': 'BTC',
             'is_position': False,
             'leverage': 1.0,
             'position': 0.0,
             'side': 'long',
+            'is_bot_managed': True,
         },
         {
             'free': 1.0,
             'balance': 5.0,
             'currency': 'ETH',
+            'bot_owned': 0,
             'est_stake': 0.30794,
+            'est_stake_bot': 0,
             'used': 4.0,
             'stake': 'BTC',
             'is_position': False,
             'leverage': 1.0,
             'position': 0.0,
             'side': 'long',
-
+            'is_bot_managed': False,
         },
         {
             'free': 5.0,
             'balance': 10.0,
             'currency': 'USDT',
+            'bot_owned': 0,
             'est_stake': 0.0011562404610161968,
+            'est_stake_bot': 0,
             'used': 5.0,
             'stake': 'BTC',
             'is_position': False,
             'leverage': 1.0,
             'position': 0.0,
             'side': 'long',
+            'is_bot_managed': False,
         },
         {
             'free': 0.0,
             'balance': 0.0,
             'currency': 'ETH/USDT:USDT',
             'est_stake': 20,
+            'est_stake_bot': 20,
             'used': 0,
             'stake': 'BTC',
             'is_position': True,
             'leverage': 5.0,
             'position': 1000.0,
             'side': 'short',
+            'is_bot_managed': True,
         }
     ]
+    assert pytest.approx(result['total_bot']) == 29.9
+    assert pytest.approx(result['total']) == 30.309096
     assert result['starting_capital'] == 10
-    assert result['starting_capital_ratio'] == 0.0
+    # Very high starting capital ratio, because the futures position really has the wrong unit.
+    # TODO: improve this test (see comment above)
+    assert result['starting_capital_ratio'] == pytest.approx(1.98999999)
 
 
 def test_rpc_start(mocker, default_conf) -> None:
diff --git a/tests/rpc/test_rpc_apiserver.py b/tests/rpc/test_rpc_apiserver.py
index 58c904838..842981ad0 100644
--- a/tests/rpc/test_rpc_apiserver.py
+++ b/tests/rpc/test_rpc_apiserver.py
@@ -21,11 +21,13 @@ from freqtrade.__init__ import __version__
 from freqtrade.enums import CandleType, RunMode, State, TradingMode
 from freqtrade.exceptions import DependencyException, ExchangeError, OperationalException
 from freqtrade.loggers import setup_logging, setup_logging_pre
+from freqtrade.optimize.backtesting import Backtesting
 from freqtrade.persistence import PairLocks, Trade
 from freqtrade.rpc import RPC
 from freqtrade.rpc.api_server import ApiServer
 from freqtrade.rpc.api_server.api_auth import create_token, get_user_from_token
 from freqtrade.rpc.api_server.uvicorn_threaded import UvicornServer
+from freqtrade.rpc.api_server.webserver_bgwork import ApiBG
 from tests.conftest import (CURRENT_TEST_STRATEGY, EXMS, create_mock_trades, get_mock_coro,
                             get_patched_freqtradebot, log_has, log_has_re, patch_get_signal)
 
@@ -283,7 +285,7 @@ def test_api__init__(default_conf, mocker):
                                         "username": "TestUser",
                                         "password": "testPass",
                                         }})
-    mocker.patch('freqtrade.rpc.telegram.Updater', MagicMock())
+    mocker.patch('freqtrade.rpc.telegram.Telegram._init')
     mocker.patch('freqtrade.rpc.api_server.webserver.ApiServer.start_api', MagicMock())
     apiserver = ApiServer(default_conf)
     apiserver.add_rpc_handler(RPC(get_patched_freqtradebot(mocker, default_conf)))
@@ -341,7 +343,7 @@ def test_api_run(default_conf, mocker, caplog):
                                         "username": "TestUser",
                                         "password": "testPass",
                                         }})
-    mocker.patch('freqtrade.rpc.telegram.Updater', MagicMock())
+    mocker.patch('freqtrade.rpc.telegram.Telegram._init')
 
     server_inst_mock = MagicMock()
     server_inst_mock.run_in_thread = MagicMock()
@@ -419,7 +421,7 @@ def test_api_cleanup(default_conf, mocker, caplog):
                                         "username": "TestUser",
                                         "password": "testPass",
                                         }})
-    mocker.patch('freqtrade.rpc.telegram.Updater', MagicMock())
+    mocker.patch('freqtrade.rpc.telegram.Telegram._init')
 
     server_mock = MagicMock()
     server_mock.cleanup = MagicMock()
@@ -480,13 +482,18 @@ def test_api_balance(botclient, mocker, rpc_balance, tickers):
         'free': 12.0,
         'balance': 12.0,
         'used': 0.0,
+        'bot_owned': pytest.approx(11.879999),
         'est_stake': 12.0,
+        'est_stake_bot': pytest.approx(11.879999),
         'stake': 'BTC',
         'is_position': False,
         'leverage': 1.0,
         'position': 0.0,
         'side': 'long',
+        'is_bot_managed': True,
     }
+    assert response['total'] == 12.159513094
+    assert response['total_bot'] == pytest.approx(11.879999)
     assert 'starting_capital' in response
     assert 'starting_capital_fiat' in response
     assert 'starting_capital_pct' in response
@@ -596,7 +603,7 @@ def test_api_daily(botclient, mocker, ticker, fee, markets):
     assert len(rc.json()['data']) == 7
     assert rc.json()['stake_currency'] == 'BTC'
     assert rc.json()['fiat_display_currency'] == 'USD'
-    assert rc.json()['data'][0]['date'] == str(datetime.utcnow().date())
+    assert rc.json()['data'][0]['date'] == str(datetime.now(timezone.utc).date())
 
 
 @pytest.mark.parametrize('is_short', [True, False])
@@ -735,6 +742,33 @@ def test_api_delete_open_order(botclient, mocker, fee, markets, ticker, is_short
     assert cancel_mock.call_count == 1
 
 
+@pytest.mark.parametrize('is_short', [True, False])
+def test_api_trade_reload_trade(botclient, mocker, fee, markets, ticker, is_short):
+    ftbot, client = botclient
+    patch_get_signal(ftbot, enter_long=not is_short, enter_short=is_short)
+    stoploss_mock = MagicMock()
+    cancel_mock = MagicMock()
+    ftbot.handle_onexchange_order = MagicMock()
+    mocker.patch.multiple(
+        EXMS,
+        markets=PropertyMock(return_value=markets),
+        fetch_ticker=ticker,
+        cancel_order=cancel_mock,
+        cancel_stoploss_order=stoploss_mock,
+    )
+
+    rc = client_post(client, f"{BASE_URI}/trades/10/reload")
+    assert_response(rc, 502)
+    assert 'Could not find trade with id 10.' in rc.json()['error']
+    assert ftbot.handle_onexchange_order.call_count == 0
+
+    create_mock_trades(fee, is_short=is_short)
+    Trade.commit()
+
+    rc = client_post(client, f"{BASE_URI}/trades/5/reload")
+    assert ftbot.handle_onexchange_order.call_count == 1
+
+
 def test_api_logs(botclient):
     ftbot, client = botclient
     rc = client_get(client, f"{BASE_URI}/logs")
@@ -856,8 +890,10 @@ def test_api_profit(botclient, mocker, ticker, fee, markets, is_short, expected)
         'best_pair_profit_ratio': expected['best_pair_profit_ratio'],
         'best_rate': expected['best_rate'],
         'first_trade_date': ANY,
+        'first_trade_humanized': ANY,
         'first_trade_timestamp': ANY,
-        'latest_trade_date': '5 minutes ago',
+        'latest_trade_date': ANY,
+        'latest_trade_humanized': '5 minutes ago',
         'latest_trade_timestamp': ANY,
         'profit_all_coin': pytest.approx(expected['profit_all_coin']),
         'profit_all_fiat': pytest.approx(expected['profit_all_fiat']),
@@ -1192,7 +1228,7 @@ def test_api_force_entry(botclient, mocker, fee, endpoint):
         stake_amount=1,
         open_rate=0.245441,
         open_order_id="123456",
-        open_date=datetime.utcnow(),
+        open_date=datetime.now(timezone.utc),
         is_open=False,
         is_short=False,
         fee_close=fee.return_value,
@@ -1631,137 +1667,140 @@ def test_sysinfo(botclient):
 
 
 def test_api_backtesting(botclient, mocker, fee, caplog, tmpdir):
-    ftbot, client = botclient
-    mocker.patch(f'{EXMS}.get_fee', fee)
+    try:
+        ftbot, client = botclient
+        mocker.patch(f'{EXMS}.get_fee', fee)
 
-    rc = client_get(client, f"{BASE_URI}/backtest")
-    # Backtest prevented in default mode
-    assert_response(rc, 502)
+        rc = client_get(client, f"{BASE_URI}/backtest")
+        # Backtest prevented in default mode
+        assert_response(rc, 502)
 
-    ftbot.config['runmode'] = RunMode.WEBSERVER
-    # Backtesting not started yet
-    rc = client_get(client, f"{BASE_URI}/backtest")
-    assert_response(rc)
+        ftbot.config['runmode'] = RunMode.WEBSERVER
+        # Backtesting not started yet
+        rc = client_get(client, f"{BASE_URI}/backtest")
+        assert_response(rc)
 
-    result = rc.json()
-    assert result['status'] == 'not_started'
-    assert not result['running']
-    assert result['status_msg'] == 'Backtest not yet executed'
-    assert result['progress'] == 0
+        result = rc.json()
+        assert result['status'] == 'not_started'
+        assert not result['running']
+        assert result['status_msg'] == 'Backtest not yet executed'
+        assert result['progress'] == 0
 
-    # Reset backtesting
-    rc = client_delete(client, f"{BASE_URI}/backtest")
-    assert_response(rc)
-    result = rc.json()
-    assert result['status'] == 'reset'
-    assert not result['running']
-    assert result['status_msg'] == 'Backtest reset'
-    ftbot.config['export'] = 'trades'
-    ftbot.config['backtest_cache'] = 'day'
-    ftbot.config['user_data_dir'] = Path(tmpdir)
-    ftbot.config['exportfilename'] = Path(tmpdir) / "backtest_results"
-    ftbot.config['exportfilename'].mkdir()
+        # Reset backtesting
+        rc = client_delete(client, f"{BASE_URI}/backtest")
+        assert_response(rc)
+        result = rc.json()
+        assert result['status'] == 'reset'
+        assert not result['running']
+        assert result['status_msg'] == 'Backtest reset'
+        ftbot.config['export'] = 'trades'
+        ftbot.config['backtest_cache'] = 'day'
+        ftbot.config['user_data_dir'] = Path(tmpdir)
+        ftbot.config['exportfilename'] = Path(tmpdir) / "backtest_results"
+        ftbot.config['exportfilename'].mkdir()
 
-    # start backtesting
-    data = {
-        "strategy": CURRENT_TEST_STRATEGY,
-        "timeframe": "5m",
-        "timerange": "20180110-20180111",
-        "max_open_trades": 3,
-        "stake_amount": 100,
-        "dry_run_wallet": 1000,
-        "enable_protections": False
-    }
-    rc = client_post(client, f"{BASE_URI}/backtest", data=data)
-    assert_response(rc)
-    result = rc.json()
+        # start backtesting
+        data = {
+            "strategy": CURRENT_TEST_STRATEGY,
+            "timeframe": "5m",
+            "timerange": "20180110-20180111",
+            "max_open_trades": 3,
+            "stake_amount": 100,
+            "dry_run_wallet": 1000,
+            "enable_protections": False
+        }
+        rc = client_post(client, f"{BASE_URI}/backtest", data=data)
+        assert_response(rc)
+        result = rc.json()
 
-    assert result['status'] == 'running'
-    assert result['progress'] == 0
-    assert result['running']
-    assert result['status_msg'] == 'Backtest started'
+        assert result['status'] == 'running'
+        assert result['progress'] == 0
+        assert result['running']
+        assert result['status_msg'] == 'Backtest started'
 
-    rc = client_get(client, f"{BASE_URI}/backtest")
-    assert_response(rc)
+        rc = client_get(client, f"{BASE_URI}/backtest")
+        assert_response(rc)
 
-    result = rc.json()
-    assert result['status'] == 'ended'
-    assert not result['running']
-    assert result['status_msg'] == 'Backtest ended'
-    assert result['progress'] == 1
-    assert result['backtest_result']
+        result = rc.json()
+        assert result['status'] == 'ended'
+        assert not result['running']
+        assert result['status_msg'] == 'Backtest ended'
+        assert result['progress'] == 1
+        assert result['backtest_result']
 
-    rc = client_get(client, f"{BASE_URI}/backtest/abort")
-    assert_response(rc)
-    result = rc.json()
-    assert result['status'] == 'not_running'
-    assert not result['running']
-    assert result['status_msg'] == 'Backtest ended'
+        rc = client_get(client, f"{BASE_URI}/backtest/abort")
+        assert_response(rc)
+        result = rc.json()
+        assert result['status'] == 'not_running'
+        assert not result['running']
+        assert result['status_msg'] == 'Backtest ended'
 
-    # Simulate running backtest
-    ApiServer._bgtask_running = True
-    rc = client_get(client, f"{BASE_URI}/backtest/abort")
-    assert_response(rc)
-    result = rc.json()
-    assert result['status'] == 'stopping'
-    assert not result['running']
-    assert result['status_msg'] == 'Backtest ended'
+        # Simulate running backtest
+        ApiBG.bgtask_running = True
+        rc = client_get(client, f"{BASE_URI}/backtest/abort")
+        assert_response(rc)
+        result = rc.json()
+        assert result['status'] == 'stopping'
+        assert not result['running']
+        assert result['status_msg'] == 'Backtest ended'
 
-    # Get running backtest...
-    rc = client_get(client, f"{BASE_URI}/backtest")
-    assert_response(rc)
-    result = rc.json()
-    assert result['status'] == 'running'
-    assert result['running']
-    assert result['step'] == "backtest"
-    assert result['status_msg'] == "Backtest running"
+        # Get running backtest...
+        rc = client_get(client, f"{BASE_URI}/backtest")
+        assert_response(rc)
+        result = rc.json()
+        assert result['status'] == 'running'
+        assert result['running']
+        assert result['step'] == "backtest"
+        assert result['status_msg'] == "Backtest running"
 
-    # Try delete with task still running
-    rc = client_delete(client, f"{BASE_URI}/backtest")
-    assert_response(rc)
-    result = rc.json()
-    assert result['status'] == 'running'
+        # Try delete with task still running
+        rc = client_delete(client, f"{BASE_URI}/backtest")
+        assert_response(rc)
+        result = rc.json()
+        assert result['status'] == 'running'
 
-    # Post to backtest that's still running
-    rc = client_post(client, f"{BASE_URI}/backtest", data=data)
-    assert_response(rc, 502)
-    result = rc.json()
-    assert 'Bot Background task already running' in result['error']
+        # Post to backtest that's still running
+        rc = client_post(client, f"{BASE_URI}/backtest", data=data)
+        assert_response(rc, 502)
+        result = rc.json()
+        assert 'Bot Background task already running' in result['error']
 
-    ApiServer._bgtask_running = False
+        ApiBG.bgtask_running = False
 
-    # Rerun backtest (should get previous result)
-    rc = client_post(client, f"{BASE_URI}/backtest", data=data)
-    assert_response(rc)
-    result = rc.json()
-    assert log_has_re('Reusing result of previous backtest.*', caplog)
+        # Rerun backtest (should get previous result)
+        rc = client_post(client, f"{BASE_URI}/backtest", data=data)
+        assert_response(rc)
+        result = rc.json()
+        assert log_has_re('Reusing result of previous backtest.*', caplog)
 
-    data['stake_amount'] = 101
+        data['stake_amount'] = 101
 
-    mocker.patch('freqtrade.optimize.backtesting.Backtesting.backtest_one_strategy',
-                 side_effect=DependencyException('DeadBeef'))
-    rc = client_post(client, f"{BASE_URI}/backtest", data=data)
-    assert log_has("Backtesting caused an error: DeadBeef", caplog)
+        mocker.patch('freqtrade.optimize.backtesting.Backtesting.backtest_one_strategy',
+                     side_effect=DependencyException('DeadBeef'))
+        rc = client_post(client, f"{BASE_URI}/backtest", data=data)
+        assert log_has("Backtesting caused an error: DeadBeef", caplog)
 
-    rc = client_get(client, f"{BASE_URI}/backtest")
-    assert_response(rc)
-    result = rc.json()
-    assert result['status'] == 'error'
-    assert 'Backtest failed' in result['status_msg']
+        rc = client_get(client, f"{BASE_URI}/backtest")
+        assert_response(rc)
+        result = rc.json()
+        assert result['status'] == 'error'
+        assert 'Backtest failed' in result['status_msg']
 
-    # Delete backtesting to avoid leakage since the backtest-object may stick around.
-    rc = client_delete(client, f"{BASE_URI}/backtest")
-    assert_response(rc)
+        # Delete backtesting to avoid leakage since the backtest-object may stick around.
+        rc = client_delete(client, f"{BASE_URI}/backtest")
+        assert_response(rc)
 
-    result = rc.json()
-    assert result['status'] == 'reset'
-    assert not result['running']
-    assert result['status_msg'] == 'Backtest reset'
+        result = rc.json()
+        assert result['status'] == 'reset'
+        assert not result['running']
+        assert result['status_msg'] == 'Backtest reset'
 
-    # Disallow base64 strategies
-    data['strategy'] = "xx:cHJpbnQoImhlbGxvIHdvcmxkIik="
-    rc = client_post(client, f"{BASE_URI}/backtest", data=data)
-    assert_response(rc, 500)
+        # Disallow base64 strategies
+        data['strategy'] = "xx:cHJpbnQoImhlbGxvIHdvcmxkIik="
+        rc = client_post(client, f"{BASE_URI}/backtest", data=data)
+        assert_response(rc, 500)
+    finally:
+        Backtesting.cleanup()
 
 
 def test_api_backtest_history(botclient, mocker, testdatadir):
@@ -1872,7 +1911,7 @@ def test_api_ws_send_msg(default_conf, mocker, caplog):
                                             "password": _TEST_PASS,
                                             "ws_token": _TEST_WS_TOKEN
                                             }})
-        mocker.patch('freqtrade.rpc.telegram.Updater')
+        mocker.patch('freqtrade.rpc.telegram.Telegram._init')
         mocker.patch('freqtrade.rpc.api_server.ApiServer.start_api')
         apiserver = ApiServer(default_conf)
         apiserver.add_rpc_handler(RPC(get_patched_freqtradebot(mocker, default_conf)))
diff --git a/tests/rpc/test_rpc_telegram.py b/tests/rpc/test_rpc_telegram.py
index 7978a2a23..51879f5ad 100644
--- a/tests/rpc/test_rpc_telegram.py
+++ b/tests/rpc/test_rpc_telegram.py
@@ -2,15 +2,16 @@
 # pragma pylint: disable=protected-access, unused-argument, invalid-name
 # pragma pylint: disable=too-many-lines, too-many-arguments
 
+import asyncio
 import logging
 import re
+import threading
 from datetime import datetime, timedelta, timezone
 from functools import reduce
 from random import choice, randint
 from string import ascii_uppercase
-from unittest.mock import ANY, MagicMock
+from unittest.mock import ANY, AsyncMock, MagicMock
 
-import arrow
 import pytest
 import time_machine
 from pandas import DataFrame
@@ -31,11 +32,17 @@ from freqtrade.persistence.models import Order
 from freqtrade.rpc import RPC
 from freqtrade.rpc.rpc import RPCException
 from freqtrade.rpc.telegram import Telegram, authorized_only
+from freqtrade.util.datetime_helpers import dt_now
 from tests.conftest import (CURRENT_TEST_STRATEGY, EXMS, create_mock_trades,
                             create_mock_trades_usdt, get_patched_freqtradebot, log_has, log_has_re,
                             patch_exchange, patch_get_signal, patch_whitelist)
 
 
+@pytest.fixture(autouse=True)
+def mock_exchange_loop(mocker):
+    mocker.patch('freqtrade.exchange.exchange.Exchange._init_async_loop')
+
+
 @pytest.fixture
 def default_conf(default_conf) -> dict:
     # Telegram is enabled by default
@@ -43,6 +50,28 @@ def default_conf(default_conf) -> dict:
     return default_conf
 
 
+@pytest.fixture
+def update():
+    message = Message(0, datetime.now(timezone.utc), Chat(0, 0))
+    _update = Update(0, message=message)
+
+    return _update
+
+
+def patch_eventloop_threading(telegrambot):
+    is_init = False
+
+    def thread_fuck():
+        nonlocal is_init
+        telegrambot._loop = asyncio.new_event_loop()
+        is_init = True
+        telegrambot._loop.run_forever()
+    x = threading.Thread(target=thread_fuck, daemon=True)
+    x.start()
+    while not is_init:
+        pass
+
+
 class DummyCls(Telegram):
     """
     Dummy class for testing the Telegram @authorized_only decorator
@@ -56,14 +85,14 @@ class DummyCls(Telegram):
         pass
 
     @authorized_only
-    def dummy_handler(self, *args, **kwargs) -> None:
+    async def dummy_handler(self, *args, **kwargs) -> None:
         """
         Fake method that only change the state of the object
         """
         self.state['called'] = True
 
     @authorized_only
-    def dummy_exception(self, *args, **kwargs) -> None:
+    async def dummy_exception(self, *args, **kwargs) -> None:
         """
         Fake method that throw an exception
         """
@@ -71,23 +100,26 @@ class DummyCls(Telegram):
 
 
 def get_telegram_testobject(mocker, default_conf, mock=True, ftbot=None):
-    msg_mock = MagicMock()
+    msg_mock = AsyncMock()
     if mock:
         mocker.patch.multiple(
             'freqtrade.rpc.telegram.Telegram',
             _init=MagicMock(),
-            _send_msg=msg_mock
+            _send_msg=msg_mock,
+            _start_thread=MagicMock(),
         )
     if not ftbot:
+        mocker.patch('freqtrade.exchange.exchange.Exchange._init_async_loop')
         ftbot = get_patched_freqtradebot(mocker, default_conf)
     rpc = RPC(ftbot)
     telegram = Telegram(rpc, default_conf)
+    telegram._loop = MagicMock()
+    patch_eventloop_threading(telegram)
 
     return telegram, ftbot, msg_mock
 
 
 def test_telegram__init__(default_conf, mocker) -> None:
-    mocker.patch('freqtrade.rpc.telegram.Updater', MagicMock())
     mocker.patch('freqtrade.rpc.telegram.Telegram._init', MagicMock())
 
     telegram, _, _ = get_telegram_testobject(mocker, default_conf)
@@ -95,43 +127,73 @@ def test_telegram__init__(default_conf, mocker) -> None:
 
 
 def test_telegram_init(default_conf, mocker, caplog) -> None:
-    start_polling = MagicMock()
-    mocker.patch('freqtrade.rpc.telegram.Updater', MagicMock(return_value=start_polling))
+    app_mock = MagicMock()
+    mocker.patch('freqtrade.rpc.telegram.Telegram._start_thread', MagicMock())
+    mocker.patch('freqtrade.rpc.telegram.Telegram._init_telegram_app', return_value=app_mock)
+    mocker.patch('freqtrade.rpc.telegram.Telegram._startup_telegram', AsyncMock())
 
-    get_telegram_testobject(mocker, default_conf, mock=False)
-    assert start_polling.call_count == 0
+    telegram, _, _ = get_telegram_testobject(mocker, default_conf, mock=False)
+    telegram._init()
+    assert app_mock.call_count == 0
 
     # number of handles registered
-    assert start_polling.dispatcher.add_handler.call_count > 0
-    assert start_polling.start_polling.call_count == 1
+    assert app_mock.add_handler.call_count > 0
+    # assert start_polling.start_polling.call_count == 1
 
     message_str = ("rpc.telegram is listening for following commands: [['status'], ['profit'], "
                    "['balance'], ['start'], ['stop'], "
-                   "['forcesell', 'forceexit', 'fx'], ['forcebuy', 'forcelong'], ['forceshort'], "
-                   "['trades'], ['delete'], ['coo', 'cancel_open_order'], ['performance'], "
-                   "['buys', 'entries'], ['sells', 'exits'], ['mix_tags'], "
+                   "['forceexit', 'forcesell', 'fx'], ['forcebuy', 'forcelong'], ['forceshort'], "
+                   "['reload_trade'], ['trades'], ['delete'], ['cancel_open_order', 'coo'], "
+                   "['performance'], ['buys', 'entries'], ['exits', 'sells'], ['mix_tags'], "
                    "['stats'], ['daily'], ['weekly'], ['monthly'], "
-                   "['count'], ['locks'], ['unlock', 'delete_locks'], "
-                   "['reload_config', 'reload_conf'], ['show_config', 'show_conf'], "
+                   "['count'], ['locks'], ['delete_locks', 'unlock'], "
+                   "['reload_conf', 'reload_config'], ['show_conf', 'show_config'], "
                    "['stopbuy', 'stopentry'], ['whitelist'], ['blacklist'], "
-                   "['blacklist_delete', 'bl_delete'], "
+                   "['bl_delete', 'blacklist_delete'], "
                    "['logs'], ['edge'], ['health'], ['help'], ['version'], ['marketdir']"
                    "]")
 
     assert log_has(message_str, caplog)
 
 
-def test_cleanup(default_conf, mocker, ) -> None:
+async def test_telegram_startup(default_conf, mocker) -> None:
+    app_mock = MagicMock()
+    app_mock.initialize = AsyncMock()
+    app_mock.start = AsyncMock()
+    app_mock.updater.start_polling = AsyncMock()
+    app_mock.updater.running = False
+    sleep_mock = mocker.patch('freqtrade.rpc.telegram.asyncio.sleep', AsyncMock())
+
+    telegram, _, _ = get_telegram_testobject(mocker, default_conf)
+    telegram._app = app_mock
+    await telegram._startup_telegram()
+    assert app_mock.initialize.call_count == 1
+    assert app_mock.start.call_count == 1
+    assert app_mock.updater.start_polling.call_count == 1
+    assert sleep_mock.call_count == 1
+
+
+async def test_telegram_cleanup(default_conf, mocker, ) -> None:
+    app_mock = MagicMock()
+    app_mock.stop = AsyncMock()
+    app_mock.initialize = AsyncMock()
+
     updater_mock = MagicMock()
-    updater_mock.stop = MagicMock()
-    mocker.patch('freqtrade.rpc.telegram.Updater', updater_mock)
+    updater_mock.stop = AsyncMock()
+    app_mock.updater = updater_mock
+    # mocker.patch('freqtrade.rpc.telegram.Application', app_mock)
 
-    telegram, _, _ = get_telegram_testobject(mocker, default_conf, mock=False)
+    telegram, _, _ = get_telegram_testobject(mocker, default_conf)
+    telegram._app = app_mock
+    telegram._loop = asyncio.get_running_loop()
+    telegram._thread = MagicMock()
     telegram.cleanup()
-    assert telegram._updater.stop.call_count == 1
+    await asyncio.sleep(0.1)
+    assert app_mock.stop.call_count == 1
+    assert telegram._thread.join.call_count == 1
 
 
-def test_authorized_only(default_conf, mocker, caplog, update) -> None:
+async def test_authorized_only(default_conf, mocker, caplog, update) -> None:
     patch_exchange(mocker)
     caplog.set_level(logging.DEBUG)
     default_conf['telegram']['enabled'] = False
@@ -140,19 +202,19 @@ def test_authorized_only(default_conf, mocker, caplog, update) -> None:
     dummy = DummyCls(rpc, default_conf)
 
     patch_get_signal(bot)
-    dummy.dummy_handler(update=update, context=MagicMock())
+    await dummy.dummy_handler(update=update, context=MagicMock())
     assert dummy.state['called'] is True
     assert log_has('Executing handler: dummy_handler for chat_id: 0', caplog)
     assert not log_has('Rejected unauthorized message from: 0', caplog)
     assert not log_has('Exception occurred within Telegram module', caplog)
 
 
-def test_authorized_only_unauthorized(default_conf, mocker, caplog) -> None:
+async def test_authorized_only_unauthorized(default_conf, mocker, caplog) -> None:
     patch_exchange(mocker)
     caplog.set_level(logging.DEBUG)
     chat = Chat(0xdeadbeef, 0)
-    update = Update(randint(1, 100))
-    update.message = Message(randint(1, 100), datetime.utcnow(), chat)
+    message = Message(randint(1, 100), datetime.now(timezone.utc), chat)
+    update = Update(randint(1, 100), message=message)
 
     default_conf['telegram']['enabled'] = False
     bot = FreqtradeBot(default_conf)
@@ -160,14 +222,14 @@ def test_authorized_only_unauthorized(default_conf, mocker, caplog) -> None:
     dummy = DummyCls(rpc, default_conf)
 
     patch_get_signal(bot)
-    dummy.dummy_handler(update=update, context=MagicMock())
+    await dummy.dummy_handler(update=update, context=MagicMock())
     assert dummy.state['called'] is False
     assert not log_has('Executing handler: dummy_handler for chat_id: 3735928559', caplog)
     assert log_has('Rejected unauthorized message from: 3735928559', caplog)
     assert not log_has('Exception occurred within Telegram module', caplog)
 
 
-def test_authorized_only_exception(default_conf, mocker, caplog, update) -> None:
+async def test_authorized_only_exception(default_conf, mocker, caplog, update) -> None:
     patch_exchange(mocker)
 
     default_conf['telegram']['enabled'] = False
@@ -177,17 +239,15 @@ def test_authorized_only_exception(default_conf, mocker, caplog, update) -> None
     dummy = DummyCls(rpc, default_conf)
     patch_get_signal(bot)
 
-    dummy.dummy_exception(update=update, context=MagicMock())
+    await dummy.dummy_exception(update=update, context=MagicMock())
     assert dummy.state['called'] is False
     assert not log_has('Executing handler: dummy_handler for chat_id: 0', caplog)
     assert not log_has('Rejected unauthorized message from: 0', caplog)
     assert log_has('Exception occurred within Telegram module', caplog)
 
 
-def test_telegram_status(default_conf, update, mocker) -> None:
-    update.message.chat.id = "123"
+async def test_telegram_status(default_conf, update, mocker) -> None:
     default_conf['telegram']['enabled'] = False
-    default_conf['telegram']['chat_id'] = "123"
 
     status_table = MagicMock()
     mocker.patch('freqtrade.rpc.telegram.Telegram._status_table', status_table)
@@ -199,7 +259,7 @@ def test_telegram_status(default_conf, update, mocker) -> None:
             'pair': 'ETH/BTC',
             'base_currency': 'ETH',
             'quote_currency': 'BTC',
-            'open_date': arrow.utcnow(),
+            'open_date': dt_now(),
             'close_date': None,
             'open_rate': 1.099e-05,
             'close_rate': None,
@@ -232,21 +292,19 @@ def test_telegram_status(default_conf, update, mocker) -> None:
 
     telegram, _, msg_mock = get_telegram_testobject(mocker, default_conf)
 
-    telegram._status(update=update, context=MagicMock())
+    await telegram._status(update=update, context=MagicMock())
     assert msg_mock.call_count == 1
 
     context = MagicMock()
     # /status table
     context.args = ["table"]
-    telegram._status(update=update, context=context)
+    await telegram._status(update=update, context=context)
     assert status_table.call_count == 1
 
 
 @pytest.mark.usefixtures("init_persistence")
-def test_telegram_status_multi_entry(default_conf, update, mocker, fee) -> None:
-    update.message.chat.id = "123"
+async def test_telegram_status_multi_entry(default_conf, update, mocker, fee) -> None:
     default_conf['telegram']['enabled'] = False
-    default_conf['telegram']['chat_id'] = "123"
     default_conf['position_adjustment_enable'] = True
     mocker.patch.multiple(
         EXMS,
@@ -284,7 +342,7 @@ def test_telegram_status_multi_entry(default_conf, update, mocker, fee) -> None:
     trade.recalc_trade_from_orders()
     Trade.commit()
 
-    telegram._status(update=update, context=MagicMock())
+    await telegram._status(update=update, context=MagicMock())
     assert msg_mock.call_count == 4
     msg = msg_mock.call_args_list[0][0][0]
     assert re.search(r'Number of Entries.*2', msg)
@@ -296,10 +354,7 @@ def test_telegram_status_multi_entry(default_conf, update, mocker, fee) -> None:
 
 
 @pytest.mark.usefixtures("init_persistence")
-def test_telegram_status_closed_trade(default_conf, update, mocker, fee) -> None:
-    update.message.chat.id = "123"
-    default_conf['telegram']['enabled'] = False
-    default_conf['telegram']['chat_id'] = "123"
+async def test_telegram_status_closed_trade(default_conf, update, mocker, fee) -> None:
     default_conf['position_adjustment_enable'] = True
     mocker.patch.multiple(
         EXMS,
@@ -313,14 +368,14 @@ def test_telegram_status_closed_trade(default_conf, update, mocker, fee) -> None
     trade = Trade.get_trades([Trade.is_open.is_(False)]).first()
     context = MagicMock()
     context.args = [str(trade.id)]
-    telegram._status(update=update, context=context)
+    await telegram._status(update=update, context=context)
     assert msg_mock.call_count == 1
     msg = msg_mock.call_args_list[0][0][0]
     assert re.search(r'Close Date:', msg)
     assert re.search(r'Close Profit:', msg)
 
 
-def test_status_handle(default_conf, update, ticker, fee, mocker) -> None:
+async def test_status_handle(default_conf, update, ticker, fee, mocker) -> None:
     default_conf['max_open_trades'] = 3
     mocker.patch.multiple(
         EXMS,
@@ -340,13 +395,13 @@ def test_status_handle(default_conf, update, ticker, fee, mocker) -> None:
 
     freqtradebot.state = State.STOPPED
     # Status is also enabled when stopped
-    telegram._status(update=update, context=MagicMock())
+    await telegram._status(update=update, context=MagicMock())
     assert msg_mock.call_count == 1
     assert 'no active trade' in msg_mock.call_args_list[0][0][0]
     msg_mock.reset_mock()
 
     freqtradebot.state = State.RUNNING
-    telegram._status(update=update, context=MagicMock())
+    await telegram._status(update=update, context=MagicMock())
     assert msg_mock.call_count == 1
     assert 'no active trade' in msg_mock.call_args_list[0][0][0]
     msg_mock.reset_mock()
@@ -354,7 +409,7 @@ def test_status_handle(default_conf, update, ticker, fee, mocker) -> None:
     # Create some test data
     freqtradebot.enter_positions()
     # Trigger status while we have a fulfilled order for the open trade
-    telegram._status(update=update, context=MagicMock())
+    await telegram._status(update=update, context=MagicMock())
 
     # close_rate should not be included in the message as the trade is not closed
     # and no line should be empty
@@ -371,7 +426,7 @@ def test_status_handle(default_conf, update, ticker, fee, mocker) -> None:
     context = MagicMock()
     context.args = ["2", "3"]
 
-    telegram._status(update=update, context=context)
+    await telegram._status(update=update, context=context)
 
     lines = msg_mock.call_args_list[0][0][0].split('\n')
     assert '' not in lines[:-1]
@@ -386,7 +441,7 @@ def test_status_handle(default_conf, update, ticker, fee, mocker) -> None:
     msg_mock.reset_mock()
     context = MagicMock()
     context.args = ["2"]
-    telegram._status(update=update, context=context)
+    await telegram._status(update=update, context=context)
 
     assert msg_mock.call_count == 2
 
@@ -398,7 +453,7 @@ def test_status_handle(default_conf, update, ticker, fee, mocker) -> None:
     assert 'Trade ID:* `2` - continued' in msg2
 
 
-def test_status_table_handle(default_conf, update, ticker, fee, mocker) -> None:
+async def test_status_table_handle(default_conf, update, ticker, fee, mocker) -> None:
     mocker.patch.multiple(
         EXMS,
         fetch_ticker=ticker,
@@ -413,13 +468,13 @@ def test_status_table_handle(default_conf, update, ticker, fee, mocker) -> None:
 
     freqtradebot.state = State.STOPPED
     # Status table is also enabled when stopped
-    telegram._status_table(update=update, context=MagicMock())
+    await telegram._status_table(update=update, context=MagicMock())
     assert msg_mock.call_count == 1
     assert 'no active trade' in msg_mock.call_args_list[0][0][0]
     msg_mock.reset_mock()
 
     freqtradebot.state = State.RUNNING
-    telegram._status_table(update=update, context=MagicMock())
+    await telegram._status_table(update=update, context=MagicMock())
     assert msg_mock.call_count == 1
     assert 'no active trade' in msg_mock.call_args_list[0][0][0]
     msg_mock.reset_mock()
@@ -427,7 +482,7 @@ def test_status_table_handle(default_conf, update, ticker, fee, mocker) -> None:
     # Create some test data
     freqtradebot.enter_positions()
 
-    telegram._status_table(update=update, context=MagicMock())
+    await telegram._status_table(update=update, context=MagicMock())
 
     text = re.sub('</?pre>', '', msg_mock.call_args_list[-1][0][0])
     line = text.split("\n")
@@ -439,7 +494,7 @@ def test_status_table_handle(default_conf, update, ticker, fee, mocker) -> None:
     assert msg_mock.call_count == 1
 
 
-def test_daily_handle(default_conf_usdt, update, ticker, fee, mocker, time_machine) -> None:
+async def test_daily_handle(default_conf_usdt, update, ticker, fee, mocker, time_machine) -> None:
     mocker.patch(
         'freqtrade.rpc.rpc.CryptoToFiatConverter._find_price',
         return_value=1.1
@@ -461,11 +516,11 @@ def test_daily_handle(default_conf_usdt, update, ticker, fee, mocker, time_machi
     # /daily 2
     context = MagicMock()
     context.args = ["2"]
-    telegram._daily(update=update, context=context)
+    await telegram._daily(update=update, context=context)
     assert msg_mock.call_count == 1
     assert "Daily Profit over the last 2 days</b>:" in msg_mock.call_args_list[0][0][0]
     assert 'Day ' in msg_mock.call_args_list[0][0][0]
-    assert str(datetime.utcnow().date()) in msg_mock.call_args_list[0][0][0]
+    assert str(datetime.now(timezone.utc).date()) in msg_mock.call_args_list[0][0][0]
     assert '  6.83 USDT' in msg_mock.call_args_list[0][0][0]
     assert '  7.51 USD' in msg_mock.call_args_list[0][0][0]
     assert '(2)' in msg_mock.call_args_list[0][0][0]
@@ -475,11 +530,12 @@ def test_daily_handle(default_conf_usdt, update, ticker, fee, mocker, time_machi
     # Reset msg_mock
     msg_mock.reset_mock()
     context.args = []
-    telegram._daily(update=update, context=context)
+    await telegram._daily(update=update, context=context)
     assert msg_mock.call_count == 1
     assert "Daily Profit over the last 7 days</b>:" in msg_mock.call_args_list[0][0][0]
-    assert str(datetime.utcnow().date()) in msg_mock.call_args_list[0][0][0]
-    assert str((datetime.utcnow() - timedelta(days=5)).date()) in msg_mock.call_args_list[0][0][0]
+    assert str(datetime.now(timezone.utc).date()) in msg_mock.call_args_list[0][0][0]
+    assert str((datetime.now(timezone.utc) - timedelta(days=5)).date()
+               ) in msg_mock.call_args_list[0][0][0]
     assert '  6.83 USDT' in msg_mock.call_args_list[0][0][0]
     assert '  7.51 USD' in msg_mock.call_args_list[0][0][0]
     assert '(2)' in msg_mock.call_args_list[0][0][0]
@@ -492,13 +548,13 @@ def test_daily_handle(default_conf_usdt, update, ticker, fee, mocker, time_machi
     # /daily 1
     context = MagicMock()
     context.args = ["1"]
-    telegram._daily(update=update, context=context)
+    await telegram._daily(update=update, context=context)
     assert '  6.83 USDT' in msg_mock.call_args_list[0][0][0]
     assert '  7.51 USD' in msg_mock.call_args_list[0][0][0]
     assert '(2)' in msg_mock.call_args_list[0][0][0]
 
 
-def test_daily_wrong_input(default_conf, update, ticker, mocker) -> None:
+async def test_daily_wrong_input(default_conf, update, ticker, mocker) -> None:
     mocker.patch.multiple(
         EXMS,
         fetch_ticker=ticker
@@ -513,7 +569,7 @@ def test_daily_wrong_input(default_conf, update, ticker, mocker) -> None:
     # /daily -2
     context = MagicMock()
     context.args = ["-2"]
-    telegram._daily(update=update, context=context)
+    await telegram._daily(update=update, context=context)
     assert msg_mock.call_count == 1
     assert 'must be an integer greater than 0' in msg_mock.call_args_list[0][0][0]
 
@@ -523,11 +579,11 @@ def test_daily_wrong_input(default_conf, update, ticker, mocker) -> None:
     # /daily today
     context = MagicMock()
     context.args = ["today"]
-    telegram._daily(update=update, context=context)
+    await telegram._daily(update=update, context=context)
     assert 'Daily Profit over the last 7 days</b>:' in msg_mock.call_args_list[0][0][0]
 
 
-def test_weekly_handle(default_conf_usdt, update, ticker, fee, mocker, time_machine) -> None:
+async def test_weekly_handle(default_conf_usdt, update, ticker, fee, mocker, time_machine) -> None:
     default_conf_usdt['max_open_trades'] = 1
     mocker.patch(
         'freqtrade.rpc.rpc.CryptoToFiatConverter._find_price',
@@ -548,12 +604,12 @@ def test_weekly_handle(default_conf_usdt, update, ticker, fee, mocker, time_mach
     # /weekly 2
     context = MagicMock()
     context.args = ["2"]
-    telegram._weekly(update=update, context=context)
+    await telegram._weekly(update=update, context=context)
     assert msg_mock.call_count == 1
     assert "Weekly Profit over the last 2 weeks (starting from Monday)</b>:" \
            in msg_mock.call_args_list[0][0][0]
     assert 'Monday ' in msg_mock.call_args_list[0][0][0]
-    today = datetime.utcnow().date()
+    today = datetime.now(timezone.utc).date()
     first_iso_day_of_current_week = today - timedelta(days=today.weekday())
     assert str(first_iso_day_of_current_week) in msg_mock.call_args_list[0][0][0]
     assert '  2.74 USDT' in msg_mock.call_args_list[0][0][0]
@@ -564,7 +620,7 @@ def test_weekly_handle(default_conf_usdt, update, ticker, fee, mocker, time_mach
     # Reset msg_mock
     msg_mock.reset_mock()
     context.args = []
-    telegram._weekly(update=update, context=context)
+    await telegram._weekly(update=update, context=context)
     assert msg_mock.call_count == 1
     assert "Weekly Profit over the last 8 weeks (starting from Monday)</b>:" \
            in msg_mock.call_args_list[0][0][0]
@@ -580,7 +636,7 @@ def test_weekly_handle(default_conf_usdt, update, ticker, fee, mocker, time_mach
     # /weekly -3
     context = MagicMock()
     context.args = ["-3"]
-    telegram._weekly(update=update, context=context)
+    await telegram._weekly(update=update, context=context)
     assert msg_mock.call_count == 1
     assert 'must be an integer greater than 0' in msg_mock.call_args_list[0][0][0]
 
@@ -590,14 +646,14 @@ def test_weekly_handle(default_conf_usdt, update, ticker, fee, mocker, time_mach
     # /weekly this week
     context = MagicMock()
     context.args = ["this week"]
-    telegram._weekly(update=update, context=context)
+    await telegram._weekly(update=update, context=context)
     assert (
         'Weekly Profit over the last 8 weeks (starting from Monday)</b>:'
         in msg_mock.call_args_list[0][0][0]
     )
 
 
-def test_monthly_handle(default_conf_usdt, update, ticker, fee, mocker, time_machine) -> None:
+async def test_monthly_handle(default_conf_usdt, update, ticker, fee, mocker, time_machine) -> None:
     default_conf_usdt['max_open_trades'] = 1
     mocker.patch(
         'freqtrade.rpc.rpc.CryptoToFiatConverter._find_price',
@@ -618,11 +674,11 @@ def test_monthly_handle(default_conf_usdt, update, ticker, fee, mocker, time_mac
     # /monthly 2
     context = MagicMock()
     context.args = ["2"]
-    telegram._monthly(update=update, context=context)
+    await telegram._monthly(update=update, context=context)
     assert msg_mock.call_count == 1
     assert 'Monthly Profit over the last 2 months</b>:' in msg_mock.call_args_list[0][0][0]
     assert 'Month ' in msg_mock.call_args_list[0][0][0]
-    today = datetime.utcnow().date()
+    today = datetime.now(timezone.utc).date()
     current_month = f"{today.year}-{today.month:02} "
     assert current_month in msg_mock.call_args_list[0][0][0]
     assert '  2.74 USDT' in msg_mock.call_args_list[0][0][0]
@@ -633,7 +689,7 @@ def test_monthly_handle(default_conf_usdt, update, ticker, fee, mocker, time_mac
     # Reset msg_mock
     msg_mock.reset_mock()
     context.args = []
-    telegram._monthly(update=update, context=context)
+    await telegram._monthly(update=update, context=context)
     assert msg_mock.call_count == 1
     # Default to 6 months
     assert 'Monthly Profit over the last 6 months</b>:' in msg_mock.call_args_list[0][0][0]
@@ -650,7 +706,7 @@ def test_monthly_handle(default_conf_usdt, update, ticker, fee, mocker, time_mac
     # /monthly 12
     context = MagicMock()
     context.args = ["12"]
-    telegram._monthly(update=update, context=context)
+    await telegram._monthly(update=update, context=context)
     assert msg_mock.call_count == 1
     assert 'Monthly Profit over the last 12 months</b>:' in msg_mock.call_args_list[0][0][0]
     assert '  2.74 USDT' in msg_mock.call_args_list[0][0][0]
@@ -667,7 +723,7 @@ def test_monthly_handle(default_conf_usdt, update, ticker, fee, mocker, time_mac
     # /monthly -3
     context = MagicMock()
     context.args = ["-3"]
-    telegram._monthly(update=update, context=context)
+    await telegram._monthly(update=update, context=context)
     assert msg_mock.call_count == 1
     assert 'must be an integer greater than 0' in msg_mock.call_args_list[0][0][0]
 
@@ -677,11 +733,11 @@ def test_monthly_handle(default_conf_usdt, update, ticker, fee, mocker, time_mac
     # /monthly february
     context = MagicMock()
     context.args = ["february"]
-    telegram._monthly(update=update, context=context)
+    await telegram._monthly(update=update, context=context)
     assert 'Monthly Profit over the last 6 months</b>:' in msg_mock.call_args_list[0][0][0]
 
 
-def test_telegram_profit_handle(
+async def test_telegram_profit_handle(
         default_conf_usdt, update, ticker_usdt, ticker_sell_up, fee,
         limit_sell_order_usdt, mocker) -> None:
     mocker.patch('freqtrade.rpc.rpc.CryptoToFiatConverter._find_price', return_value=1.1)
@@ -694,7 +750,7 @@ def test_telegram_profit_handle(
     telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf_usdt)
     patch_get_signal(freqtradebot)
 
-    telegram._profit(update=update, context=MagicMock())
+    await telegram._profit(update=update, context=MagicMock())
     assert msg_mock.call_count == 1
     assert 'No trades yet.' in msg_mock.call_args_list[0][0][0]
     msg_mock.reset_mock()
@@ -706,7 +762,7 @@ def test_telegram_profit_handle(
     context = MagicMock()
     # Test with invalid 2nd argument (should silently pass)
     context.args = ["aaa"]
-    telegram._profit(update=update, context=context)
+    await telegram._profit(update=update, context=context)
     assert msg_mock.call_count == 1
     assert 'No closed trade' in msg_mock.call_args_list[-1][0][0]
     assert '*ROI:* All trades' in msg_mock.call_args_list[-1][0][0]
@@ -729,7 +785,7 @@ def test_telegram_profit_handle(
     Trade.commit()
 
     context.args = [3]
-    telegram._profit(update=update, context=context)
+    await telegram._profit(update=update, context=context)
     assert msg_mock.call_count == 1
     assert '*ROI:* Closed trades' in msg_mock.call_args_list[-1][0][0]
     assert ('∙ `5.685 USDT (9.45%) (0.57 \N{GREEK CAPITAL LETTER SIGMA}%)`'
@@ -747,7 +803,7 @@ def test_telegram_profit_handle(
 
 
 @pytest.mark.parametrize('is_short', [True, False])
-def test_telegram_stats(default_conf, update, ticker, fee, mocker, is_short) -> None:
+async def test_telegram_stats(default_conf, update, ticker, fee, mocker, is_short) -> None:
     mocker.patch('freqtrade.rpc.rpc.CryptoToFiatConverter._find_price', return_value=15000.0)
     mocker.patch.multiple(
         EXMS,
@@ -757,7 +813,7 @@ def test_telegram_stats(default_conf, update, ticker, fee, mocker, is_short) ->
     telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf)
     patch_get_signal(freqtradebot)
 
-    telegram._stats(update=update, context=MagicMock())
+    await telegram._stats(update=update, context=MagicMock())
     assert msg_mock.call_count == 1
     assert 'No trades yet.' in msg_mock.call_args_list[0][0][0]
     msg_mock.reset_mock()
@@ -765,15 +821,18 @@ def test_telegram_stats(default_conf, update, ticker, fee, mocker, is_short) ->
     # Create some test data
     create_mock_trades(fee, is_short=is_short)
 
-    telegram._stats(update=update, context=MagicMock())
+    await telegram._stats(update=update, context=MagicMock())
     assert msg_mock.call_count == 1
     assert 'Exit Reason' in msg_mock.call_args_list[-1][0][0]
     assert 'ROI' in msg_mock.call_args_list[-1][0][0]
     assert 'Avg. Duration' in msg_mock.call_args_list[-1][0][0]
+    # Duration is not only N/A
+    assert '0:19:00' in msg_mock.call_args_list[-1][0][0]
+    assert 'N/A' in msg_mock.call_args_list[-1][0][0]
     msg_mock.reset_mock()
 
 
-def test_telegram_balance_handle(default_conf, update, mocker, rpc_balance, tickers) -> None:
+async def test_telegram_balance_handle(default_conf, update, mocker, rpc_balance, tickers) -> None:
     default_conf['dry_run'] = False
     mocker.patch(f'{EXMS}.get_balances', return_value=rpc_balance)
     mocker.patch(f'{EXMS}.get_tickers', tickers)
@@ -782,23 +841,32 @@ def test_telegram_balance_handle(default_conf, update, mocker, rpc_balance, tick
     telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf)
     patch_get_signal(freqtradebot)
 
-    telegram._balance(update=update, context=MagicMock())
+    await telegram._balance(update=update, context=MagicMock())
+    context = MagicMock()
+    context.args = ["full"]
+    await telegram._balance(update=update, context=context)
     result = msg_mock.call_args_list[0][0][0]
-    assert msg_mock.call_count == 1
+    result_full = msg_mock.call_args_list[1][0][0]
+    assert msg_mock.call_count == 2
     assert '*BTC:*' in result
     assert '*ETH:*' not in result
     assert '*USDT:*' not in result
     assert '*EUR:*' not in result
-    assert '*LTC:*' in result
+    assert '*LTC:*' not in result
+
+    assert '*LTC:*' in result_full
     assert '*XRP:*' not in result
     assert 'Balance:' in result
     assert 'Est. BTC:' in result
-    assert 'BTC: 12' in result
+    assert 'BTC: 11' in result
+    assert 'BTC: 12' in result_full
     assert "*3 Other Currencies (< 0.0001 BTC):*" in result
     assert 'BTC: 0.00000309' in result
+    assert '*Estimated Value*:' in result_full
+    assert '*Estimated Value (Bot managed assets only)*:' in result
 
 
-def test_balance_handle_empty_response(default_conf, update, mocker) -> None:
+async def test_balance_handle_empty_response(default_conf, update, mocker) -> None:
     default_conf['dry_run'] = False
     mocker.patch(f'{EXMS}.get_balances', return_value={})
 
@@ -806,26 +874,26 @@ def test_balance_handle_empty_response(default_conf, update, mocker) -> None:
     patch_get_signal(freqtradebot)
 
     freqtradebot.config['dry_run'] = False
-    telegram._balance(update=update, context=MagicMock())
+    await telegram._balance(update=update, context=MagicMock())
     result = msg_mock.call_args_list[0][0][0]
     assert msg_mock.call_count == 1
     assert 'Starting capital: `0 BTC' in result
 
 
-def test_balance_handle_empty_response_dry(default_conf, update, mocker) -> None:
+async def test_balance_handle_empty_response_dry(default_conf, update, mocker) -> None:
     mocker.patch(f'{EXMS}.get_balances', return_value={})
 
     telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf)
     patch_get_signal(freqtradebot)
 
-    telegram._balance(update=update, context=MagicMock())
+    await telegram._balance(update=update, context=MagicMock())
     result = msg_mock.call_args_list[0][0][0]
     assert msg_mock.call_count == 1
     assert "*Warning:* Simulated balances in Dry Mode." in result
     assert "Starting capital: `1000 BTC`" in result
 
 
-def test_balance_handle_too_large_response(default_conf, update, mocker) -> None:
+async def test_balance_handle_too_large_response(default_conf, update, mocker) -> None:
     balances = []
     for i in range(100):
         curr = choice(ascii_uppercase) + choice(ascii_uppercase) + choice(ascii_uppercase)
@@ -834,18 +902,23 @@ def test_balance_handle_too_large_response(default_conf, update, mocker) -> None
             'free': 1.0,
             'used': 0.5,
             'balance': i,
+            'bot_owned': 0.5,
             'est_stake': 1,
+            'est_stake_bot': 1,
             'stake': 'BTC',
             'is_position': False,
             'leverage': 1.0,
             'position': 0.0,
             'side': 'long',
+            'is_bot_managed': True,
         })
     mocker.patch('freqtrade.rpc.rpc.RPC._rpc_balance', return_value={
         'currencies': balances,
         'total': 100.0,
+        'total_bot': 100.0,
         'symbol': 100.0,
         'value': 1000.0,
+        'value_bot': 1000.0,
         'starting_capital': 1000,
         'starting_capital_fiat': 1000,
     })
@@ -853,7 +926,7 @@ def test_balance_handle_too_large_response(default_conf, update, mocker) -> None
     telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf)
     patch_get_signal(freqtradebot)
 
-    telegram._balance(update=update, context=MagicMock())
+    await telegram._balance(update=update, context=MagicMock())
     assert msg_mock.call_count > 1
     # Test if wrap happens around 4000 -
     # and each single currency-output is around 120 characters long so we need
@@ -862,79 +935,79 @@ def test_balance_handle_too_large_response(default_conf, update, mocker) -> None
     assert len(msg_mock.call_args_list[0][0][0]) > (4096 - 120)
 
 
-def test_start_handle(default_conf, update, mocker) -> None:
+async def test_start_handle(default_conf, update, mocker) -> None:
 
     telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf)
 
     freqtradebot.state = State.STOPPED
     assert freqtradebot.state == State.STOPPED
-    telegram._start(update=update, context=MagicMock())
+    await telegram._start(update=update, context=MagicMock())
     assert freqtradebot.state == State.RUNNING
     assert msg_mock.call_count == 1
 
 
-def test_start_handle_already_running(default_conf, update, mocker) -> None:
+async def test_start_handle_already_running(default_conf, update, mocker) -> None:
 
     telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf)
 
     freqtradebot.state = State.RUNNING
     assert freqtradebot.state == State.RUNNING
-    telegram._start(update=update, context=MagicMock())
+    await telegram._start(update=update, context=MagicMock())
     assert freqtradebot.state == State.RUNNING
     assert msg_mock.call_count == 1
     assert 'already running' in msg_mock.call_args_list[0][0][0]
 
 
-def test_stop_handle(default_conf, update, mocker) -> None:
+async def test_stop_handle(default_conf, update, mocker) -> None:
 
     telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf)
 
     freqtradebot.state = State.RUNNING
     assert freqtradebot.state == State.RUNNING
-    telegram._stop(update=update, context=MagicMock())
+    await telegram._stop(update=update, context=MagicMock())
     assert freqtradebot.state == State.STOPPED
     assert msg_mock.call_count == 1
     assert 'stopping trader' in msg_mock.call_args_list[0][0][0]
 
 
-def test_stop_handle_already_stopped(default_conf, update, mocker) -> None:
+async def test_stop_handle_already_stopped(default_conf, update, mocker) -> None:
 
     telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf)
 
     freqtradebot.state = State.STOPPED
     assert freqtradebot.state == State.STOPPED
-    telegram._stop(update=update, context=MagicMock())
+    await telegram._stop(update=update, context=MagicMock())
     assert freqtradebot.state == State.STOPPED
     assert msg_mock.call_count == 1
     assert 'already stopped' in msg_mock.call_args_list[0][0][0]
 
 
-def test_stopbuy_handle(default_conf, update, mocker) -> None:
+async def test_stopbuy_handle(default_conf, update, mocker) -> None:
 
     telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf)
 
     assert freqtradebot.config['max_open_trades'] != 0
-    telegram._stopentry(update=update, context=MagicMock())
+    await telegram._stopentry(update=update, context=MagicMock())
     assert freqtradebot.config['max_open_trades'] == 0
     assert msg_mock.call_count == 1
     assert 'No more entries will occur from now. Run /reload_config to reset.' \
         in msg_mock.call_args_list[0][0][0]
 
 
-def test_reload_config_handle(default_conf, update, mocker) -> None:
+async def test_reload_config_handle(default_conf, update, mocker) -> None:
 
     telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf)
 
     freqtradebot.state = State.RUNNING
     assert freqtradebot.state == State.RUNNING
-    telegram._reload_config(update=update, context=MagicMock())
+    await telegram._reload_config(update=update, context=MagicMock())
     assert freqtradebot.state == State.RELOAD_CONFIG
     assert msg_mock.call_count == 1
     assert 'Reloading config' in msg_mock.call_args_list[0][0][0]
 
 
-def test_telegram_forceexit_handle(default_conf, update, ticker, fee,
-                                   ticker_sell_up, mocker) -> None:
+async def test_telegram_forceexit_handle(default_conf, update, ticker, fee,
+                                         ticker_sell_up, mocker) -> None:
     mocker.patch('freqtrade.rpc.rpc.CryptoToFiatConverter._find_price', return_value=15000.0)
     msg_mock = mocker.patch('freqtrade.rpc.telegram.Telegram.send_msg', MagicMock())
     mocker.patch('freqtrade.rpc.telegram.Telegram._init', MagicMock())
@@ -964,7 +1037,7 @@ def test_telegram_forceexit_handle(default_conf, update, ticker, fee,
     # /forceexit 1
     context = MagicMock()
     context.args = ["1"]
-    telegram._force_exit(update=update, context=context)
+    await telegram._force_exit(update=update, context=context)
 
     assert msg_mock.call_count == 4
     last_msg = msg_mock.call_args_list[-2][0][0]
@@ -1000,8 +1073,8 @@ def test_telegram_forceexit_handle(default_conf, update, ticker, fee,
     } == last_msg
 
 
-def test_telegram_force_exit_down_handle(default_conf, update, ticker, fee,
-                                         ticker_sell_down, mocker) -> None:
+async def test_telegram_force_exit_down_handle(default_conf, update, ticker, fee,
+                                               ticker_sell_down, mocker) -> None:
     mocker.patch('freqtrade.rpc.fiat_convert.CryptoToFiatConverter._find_price',
                  return_value=15000.0)
     msg_mock = mocker.patch('freqtrade.rpc.telegram.Telegram.send_msg', MagicMock())
@@ -1036,7 +1109,7 @@ def test_telegram_force_exit_down_handle(default_conf, update, ticker, fee,
     # /forceexit 1
     context = MagicMock()
     context.args = ["1"]
-    telegram._force_exit(update=update, context=context)
+    await telegram._force_exit(update=update, context=context)
 
     assert msg_mock.call_count == 4
 
@@ -1073,7 +1146,7 @@ def test_telegram_force_exit_down_handle(default_conf, update, ticker, fee,
     } == last_msg
 
 
-def test_forceexit_all_handle(default_conf, update, ticker, fee, mocker) -> None:
+async def test_forceexit_all_handle(default_conf, update, ticker, fee, mocker) -> None:
     patch_exchange(mocker)
     mocker.patch('freqtrade.rpc.fiat_convert.CryptoToFiatConverter._find_price',
                  return_value=15000.0)
@@ -1099,7 +1172,7 @@ def test_forceexit_all_handle(default_conf, update, ticker, fee, mocker) -> None
     # /forceexit all
     context = MagicMock()
     context.args = ["all"]
-    telegram._force_exit(update=update, context=context)
+    await telegram._force_exit(update=update, context=context)
 
     # Called for each trade 2 times
     assert msg_mock.call_count == 8
@@ -1136,7 +1209,7 @@ def test_forceexit_all_handle(default_conf, update, ticker, fee, mocker) -> None
     } == msg
 
 
-def test_forceexit_handle_invalid(default_conf, update, mocker) -> None:
+async def test_forceexit_handle_invalid(default_conf, update, mocker) -> None:
     mocker.patch('freqtrade.rpc.fiat_convert.CryptoToFiatConverter._find_price',
                  return_value=15000.0)
 
@@ -1148,7 +1221,7 @@ def test_forceexit_handle_invalid(default_conf, update, mocker) -> None:
     # /forceexit 1
     context = MagicMock()
     context.args = ["1"]
-    telegram._force_exit(update=update, context=context)
+    await telegram._force_exit(update=update, context=context)
     assert msg_mock.call_count == 1
     assert 'not running' in msg_mock.call_args_list[0][0][0]
 
@@ -1158,12 +1231,12 @@ def test_forceexit_handle_invalid(default_conf, update, mocker) -> None:
     # /forceexit 123456
     context = MagicMock()
     context.args = ["123456"]
-    telegram._force_exit(update=update, context=context)
+    await telegram._force_exit(update=update, context=context)
     assert msg_mock.call_count == 1
     assert 'invalid argument' in msg_mock.call_args_list[0][0][0]
 
 
-def test_force_exit_no_pair(default_conf, update, ticker, fee, mocker) -> None:
+async def test_force_exit_no_pair(default_conf, update, ticker, fee, mocker) -> None:
     default_conf['max_open_trades'] = 4
     mocker.patch.multiple(
         EXMS,
@@ -1179,7 +1252,7 @@ def test_force_exit_no_pair(default_conf, update, ticker, fee, mocker) -> None:
     # /forceexit
     context = MagicMock()
     context.args = []
-    telegram._force_exit(update=update, context=context)
+    await telegram._force_exit(update=update, context=context)
     # No pair
     assert msg_mock.call_args_list[0][1]['msg'] == 'No open trade found.'
 
@@ -1188,7 +1261,7 @@ def test_force_exit_no_pair(default_conf, update, ticker, fee, mocker) -> None:
     msg_mock.reset_mock()
 
     # /forceexit
-    telegram._force_exit(update=update, context=context)
+    await telegram._force_exit(update=update, context=context)
     keyboard = msg_mock.call_args_list[0][1]['keyboard']
     # 4 pairs + cancel
     assert reduce(lambda acc, x: acc + len(x), keyboard, 0) == 5
@@ -1196,9 +1269,9 @@ def test_force_exit_no_pair(default_conf, update, ticker, fee, mocker) -> None:
 
     assert keyboard[1][0].callback_data == 'force_exit__2 '
     update = MagicMock()
-    update.callback_query = MagicMock()
+    update.callback_query = AsyncMock()
     update.callback_query.data = keyboard[1][0].callback_data
-    telegram._force_exit_inline(update, None)
+    await telegram._force_exit_inline(update, None)
     assert update.callback_query.answer.call_count == 1
     assert update.callback_query.edit_message_text.call_count == 1
     assert femock.call_count == 1
@@ -1206,17 +1279,17 @@ def test_force_exit_no_pair(default_conf, update, ticker, fee, mocker) -> None:
 
     # Retry exiting - but cancel instead
     update.callback_query.reset_mock()
-    telegram._force_exit(update=update, context=context)
+    await telegram._force_exit(update=update, context=context)
     # Use cancel button
     update.callback_query.data = keyboard[-1][0].callback_data
-    telegram._force_exit_inline(update, None)
+    await telegram._force_exit_inline(update, None)
     query = update.callback_query
     assert query.answer.call_count == 1
     assert query.edit_message_text.call_count == 1
     assert query.edit_message_text.call_args_list[-1][1]['text'] == "Force exit canceled."
 
 
-def test_force_enter_handle(default_conf, update, mocker) -> None:
+async def test_force_enter_handle(default_conf, update, mocker) -> None:
     mocker.patch('freqtrade.rpc.rpc.CryptoToFiatConverter._find_price', return_value=15000.0)
 
     fbuy_mock = MagicMock(return_value=None)
@@ -1228,7 +1301,7 @@ def test_force_enter_handle(default_conf, update, mocker) -> None:
     # /forcelong ETH/BTC
     context = MagicMock()
     context.args = ["ETH/BTC"]
-    telegram._force_enter(update=update, context=context, order_side=SignalDirection.LONG)
+    await telegram._force_enter(update=update, context=context, order_side=SignalDirection.LONG)
 
     assert fbuy_mock.call_count == 1
     assert fbuy_mock.call_args_list[0][0][0] == 'ETH/BTC'
@@ -1241,7 +1314,7 @@ def test_force_enter_handle(default_conf, update, mocker) -> None:
     # /forcelong ETH/BTC 0.055
     context = MagicMock()
     context.args = ["ETH/BTC", "0.055"]
-    telegram._force_enter(update=update, context=context, order_side=SignalDirection.LONG)
+    await telegram._force_enter(update=update, context=context, order_side=SignalDirection.LONG)
 
     assert fbuy_mock.call_count == 1
     assert fbuy_mock.call_args_list[0][0][0] == 'ETH/BTC'
@@ -1249,20 +1322,19 @@ def test_force_enter_handle(default_conf, update, mocker) -> None:
     assert fbuy_mock.call_args_list[0][0][1] == 0.055
 
 
-def test_force_enter_handle_exception(default_conf, update, mocker) -> None:
+async def test_force_enter_handle_exception(default_conf, update, mocker) -> None:
     mocker.patch('freqtrade.rpc.rpc.CryptoToFiatConverter._find_price', return_value=15000.0)
 
     telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf)
     patch_get_signal(freqtradebot)
 
-    update.message.text = '/forcebuy ETH/Nonepair'
-    telegram._force_enter(update=update, context=MagicMock(), order_side=SignalDirection.LONG)
+    await telegram._force_enter(update=update, context=MagicMock(), order_side=SignalDirection.LONG)
 
     assert msg_mock.call_count == 1
     assert msg_mock.call_args_list[0][0][0] == 'Force_entry not enabled.'
 
 
-def test_force_enter_no_pair(default_conf, update, mocker) -> None:
+async def test_force_enter_no_pair(default_conf, update, mocker) -> None:
     mocker.patch('freqtrade.rpc.rpc.CryptoToFiatConverter._find_price', return_value=15000.0)
 
     fbuy_mock = MagicMock(return_value=None)
@@ -1274,7 +1346,7 @@ def test_force_enter_no_pair(default_conf, update, mocker) -> None:
 
     context = MagicMock()
     context.args = []
-    telegram._force_enter(update=update, context=context, order_side=SignalDirection.LONG)
+    await telegram._force_enter(update=update, context=context, order_side=SignalDirection.LONG)
 
     assert fbuy_mock.call_count == 0
     assert msg_mock.call_count == 1
@@ -1284,13 +1356,13 @@ def test_force_enter_no_pair(default_conf, update, mocker) -> None:
     # One additional button - cancel
     assert reduce(lambda acc, x: acc + len(x), keyboard, 0) == 5
     update = MagicMock()
-    update.callback_query = MagicMock()
+    update.callback_query = AsyncMock()
     update.callback_query.data = 'XRP/USDT_||_long'
-    telegram._force_enter_inline(update, None)
+    await telegram._force_enter_inline(update, None)
     assert fbuy_mock.call_count == 1
 
 
-def test_telegram_performance_handle(default_conf_usdt, update, ticker, fee, mocker) -> None:
+async def test_telegram_performance_handle(default_conf_usdt, update, ticker, fee, mocker) -> None:
 
     mocker.patch.multiple(
         EXMS,
@@ -1302,13 +1374,13 @@ def test_telegram_performance_handle(default_conf_usdt, update, ticker, fee, moc
     # Create some test data
     create_mock_trades_usdt(fee)
 
-    telegram._performance(update=update, context=MagicMock())
+    await telegram._performance(update=update, context=MagicMock())
     assert msg_mock.call_count == 1
     assert 'Performance' in msg_mock.call_args_list[0][0][0]
     assert '<code>XRP/USDT\t2.842 USDT (10.00%) (1)</code>' in msg_mock.call_args_list[0][0][0]
 
 
-def test_telegram_entry_tag_performance_handle(
+async def test_telegram_entry_tag_performance_handle(
         default_conf_usdt, update, ticker, fee, mocker) -> None:
     mocker.patch.multiple(
         EXMS,
@@ -1321,26 +1393,26 @@ def test_telegram_entry_tag_performance_handle(
     create_mock_trades_usdt(fee)
 
     context = MagicMock()
-    telegram._enter_tag_performance(update=update, context=context)
+    await telegram._enter_tag_performance(update=update, context=context)
     assert msg_mock.call_count == 1
     assert 'Entry Tag Performance' in msg_mock.call_args_list[0][0][0]
     assert '<code>TEST1\t3.987 USDT (5.00%) (1)</code>' in msg_mock.call_args_list[0][0][0]
 
     context.args = ['XRP/USDT']
-    telegram._enter_tag_performance(update=update, context=context)
+    await telegram._enter_tag_performance(update=update, context=context)
     assert msg_mock.call_count == 2
 
     msg_mock.reset_mock()
     mocker.patch('freqtrade.rpc.rpc.RPC._rpc_enter_tag_performance',
                  side_effect=RPCException('Error'))
-    telegram._enter_tag_performance(update=update, context=MagicMock())
+    await telegram._enter_tag_performance(update=update, context=MagicMock())
 
     assert msg_mock.call_count == 1
     assert "Error" in msg_mock.call_args_list[0][0][0]
 
 
-def test_telegram_exit_reason_performance_handle(default_conf_usdt, update, ticker, fee,
-                                                 mocker) -> None:
+async def test_telegram_exit_reason_performance_handle(
+        default_conf_usdt, update, ticker, fee, mocker) -> None:
     mocker.patch.multiple(
         EXMS,
         fetch_ticker=ticker,
@@ -1352,26 +1424,26 @@ def test_telegram_exit_reason_performance_handle(default_conf_usdt, update, tick
     create_mock_trades_usdt(fee)
 
     context = MagicMock()
-    telegram._exit_reason_performance(update=update, context=context)
+    await telegram._exit_reason_performance(update=update, context=context)
     assert msg_mock.call_count == 1
     assert 'Exit Reason Performance' in msg_mock.call_args_list[0][0][0]
     assert '<code>roi\t2.842 USDT (10.00%) (1)</code>' in msg_mock.call_args_list[0][0][0]
     context.args = ['XRP/USDT']
 
-    telegram._exit_reason_performance(update=update, context=context)
+    await telegram._exit_reason_performance(update=update, context=context)
     assert msg_mock.call_count == 2
 
     msg_mock.reset_mock()
     mocker.patch('freqtrade.rpc.rpc.RPC._rpc_exit_reason_performance',
                  side_effect=RPCException('Error'))
-    telegram._exit_reason_performance(update=update, context=MagicMock())
+    await telegram._exit_reason_performance(update=update, context=MagicMock())
 
     assert msg_mock.call_count == 1
     assert "Error" in msg_mock.call_args_list[0][0][0]
 
 
-def test_telegram_mix_tag_performance_handle(default_conf_usdt, update, ticker, fee,
-                                             mocker) -> None:
+async def test_telegram_mix_tag_performance_handle(default_conf_usdt, update, ticker, fee,
+                                                   mocker) -> None:
     mocker.patch.multiple(
         EXMS,
         fetch_ticker=ticker,
@@ -1384,26 +1456,26 @@ def test_telegram_mix_tag_performance_handle(default_conf_usdt, update, ticker,
     create_mock_trades_usdt(fee)
 
     context = MagicMock()
-    telegram._mix_tag_performance(update=update, context=context)
+    await telegram._mix_tag_performance(update=update, context=context)
     assert msg_mock.call_count == 1
     assert 'Mix Tag Performance' in msg_mock.call_args_list[0][0][0]
     assert ('<code>TEST3 roi\t2.842 USDT (10.00%) (1)</code>'
             in msg_mock.call_args_list[0][0][0])
 
     context.args = ['XRP/USDT']
-    telegram._mix_tag_performance(update=update, context=context)
+    await telegram._mix_tag_performance(update=update, context=context)
     assert msg_mock.call_count == 2
 
     msg_mock.reset_mock()
     mocker.patch('freqtrade.rpc.rpc.RPC._rpc_mix_tag_performance',
                  side_effect=RPCException('Error'))
-    telegram._mix_tag_performance(update=update, context=MagicMock())
+    await telegram._mix_tag_performance(update=update, context=MagicMock())
 
     assert msg_mock.call_count == 1
     assert "Error" in msg_mock.call_args_list[0][0][0]
 
 
-def test_count_handle(default_conf, update, ticker, fee, mocker) -> None:
+async def test_count_handle(default_conf, update, ticker, fee, mocker) -> None:
     mocker.patch.multiple(
         EXMS,
         fetch_ticker=ticker,
@@ -1413,7 +1485,7 @@ def test_count_handle(default_conf, update, ticker, fee, mocker) -> None:
     patch_get_signal(freqtradebot)
 
     freqtradebot.state = State.STOPPED
-    telegram._count(update=update, context=MagicMock())
+    await telegram._count(update=update, context=MagicMock())
     assert msg_mock.call_count == 1
     assert 'not running' in msg_mock.call_args_list[0][0][0]
     msg_mock.reset_mock()
@@ -1422,7 +1494,7 @@ def test_count_handle(default_conf, update, ticker, fee, mocker) -> None:
     # Create some test data
     freqtradebot.enter_positions()
     msg_mock.reset_mock()
-    telegram._count(update=update, context=MagicMock())
+    await telegram._count(update=update, context=MagicMock())
 
     msg = ('<pre>  current    max    total stake\n---------  -----  -------------\n'
            '        1      {}          {}</pre>').format(
@@ -1432,7 +1504,7 @@ def test_count_handle(default_conf, update, ticker, fee, mocker) -> None:
     assert msg in msg_mock.call_args_list[0][0][0]
 
 
-def test_telegram_lock_handle(default_conf, update, ticker, fee, mocker) -> None:
+async def test_telegram_lock_handle(default_conf, update, ticker, fee, mocker) -> None:
     mocker.patch.multiple(
         EXMS,
         fetch_ticker=ticker,
@@ -1440,16 +1512,16 @@ def test_telegram_lock_handle(default_conf, update, ticker, fee, mocker) -> None
     )
     telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf)
     patch_get_signal(freqtradebot)
-    telegram._locks(update=update, context=MagicMock())
+    await telegram._locks(update=update, context=MagicMock())
     assert msg_mock.call_count == 1
     assert 'No active locks.' in msg_mock.call_args_list[0][0][0]
 
     msg_mock.reset_mock()
 
-    PairLocks.lock_pair('ETH/BTC', arrow.utcnow().shift(minutes=4).datetime, 'randreason')
-    PairLocks.lock_pair('XRP/BTC', arrow.utcnow().shift(minutes=20).datetime, 'deadbeef')
+    PairLocks.lock_pair('ETH/BTC', dt_now() + timedelta(minutes=4), 'randreason')
+    PairLocks.lock_pair('XRP/BTC', dt_now() + timedelta(minutes=20), 'deadbeef')
 
-    telegram._locks(update=update, context=MagicMock())
+    await telegram._locks(update=update, context=MagicMock())
 
     assert 'Pair' in msg_mock.call_args_list[0][0][0]
     assert 'Until' in msg_mock.call_args_list[0][0][0]
@@ -1462,7 +1534,7 @@ def test_telegram_lock_handle(default_conf, update, ticker, fee, mocker) -> None
     context = MagicMock()
     context.args = ['XRP/BTC']
     msg_mock.reset_mock()
-    telegram._delete_locks(update=update, context=context)
+    await telegram._delete_locks(update=update, context=context)
 
     assert 'ETH/BTC' in msg_mock.call_args_list[0][0][0]
     assert 'randreason' in msg_mock.call_args_list[0][0][0]
@@ -1470,11 +1542,11 @@ def test_telegram_lock_handle(default_conf, update, ticker, fee, mocker) -> None
     assert 'deadbeef' not in msg_mock.call_args_list[0][0][0]
 
 
-def test_whitelist_static(default_conf, update, mocker) -> None:
+async def test_whitelist_static(default_conf, update, mocker) -> None:
 
     telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf)
 
-    telegram._whitelist(update=update, context=MagicMock())
+    await telegram._whitelist(update=update, context=MagicMock())
     assert msg_mock.call_count == 1
     assert ("Using whitelist `['StaticPairList']` with 4 pairs\n"
             "`ETH/BTC, LTC/BTC, XRP/BTC, NEO/BTC`" in msg_mock.call_args_list[0][0][0])
@@ -1482,33 +1554,33 @@ def test_whitelist_static(default_conf, update, mocker) -> None:
     context = MagicMock()
     context.args = ['sorted']
     msg_mock.reset_mock()
-    telegram._whitelist(update=update, context=context)
+    await telegram._whitelist(update=update, context=context)
     assert ("Using whitelist `['StaticPairList']` with 4 pairs\n"
             "`ETH/BTC, LTC/BTC, NEO/BTC, XRP/BTC`" in msg_mock.call_args_list[0][0][0])
 
     context = MagicMock()
     context.args = ['baseonly']
     msg_mock.reset_mock()
-    telegram._whitelist(update=update, context=context)
+    await telegram._whitelist(update=update, context=context)
     assert ("Using whitelist `['StaticPairList']` with 4 pairs\n"
             "`ETH, LTC, XRP, NEO`" in msg_mock.call_args_list[0][0][0])
 
     context = MagicMock()
     context.args = ['baseonly', 'sorted']
     msg_mock.reset_mock()
-    telegram._whitelist(update=update, context=context)
+    await telegram._whitelist(update=update, context=context)
     assert ("Using whitelist `['StaticPairList']` with 4 pairs\n"
             "`ETH, LTC, NEO, XRP`" in msg_mock.call_args_list[0][0][0])
 
 
-def test_whitelist_dynamic(default_conf, update, mocker) -> None:
+async def test_whitelist_dynamic(default_conf, update, mocker) -> None:
     mocker.patch(f'{EXMS}.exchange_has', return_value=True)
     default_conf['pairlists'] = [{'method': 'VolumePairList',
                                   'number_assets': 4
                                   }]
     telegram, _, msg_mock = get_telegram_testobject(mocker, default_conf)
 
-    telegram._whitelist(update=update, context=MagicMock())
+    await telegram._whitelist(update=update, context=MagicMock())
     assert msg_mock.call_count == 1
     assert ("Using whitelist `['VolumePairList']` with 4 pairs\n"
             "`ETH/BTC, LTC/BTC, XRP/BTC, NEO/BTC`" in msg_mock.call_args_list[0][0][0])
@@ -1516,30 +1588,30 @@ def test_whitelist_dynamic(default_conf, update, mocker) -> None:
     context = MagicMock()
     context.args = ['sorted']
     msg_mock.reset_mock()
-    telegram._whitelist(update=update, context=context)
+    await telegram._whitelist(update=update, context=context)
     assert ("Using whitelist `['VolumePairList']` with 4 pairs\n"
             "`ETH/BTC, LTC/BTC, NEO/BTC, XRP/BTC`" in msg_mock.call_args_list[0][0][0])
 
     context = MagicMock()
     context.args = ['baseonly']
     msg_mock.reset_mock()
-    telegram._whitelist(update=update, context=context)
+    await telegram._whitelist(update=update, context=context)
     assert ("Using whitelist `['VolumePairList']` with 4 pairs\n"
             "`ETH, LTC, XRP, NEO`" in msg_mock.call_args_list[0][0][0])
 
     context = MagicMock()
     context.args = ['baseonly', 'sorted']
     msg_mock.reset_mock()
-    telegram._whitelist(update=update, context=context)
+    await telegram._whitelist(update=update, context=context)
     assert ("Using whitelist `['VolumePairList']` with 4 pairs\n"
             "`ETH, LTC, NEO, XRP`" in msg_mock.call_args_list[0][0][0])
 
 
-def test_blacklist_static(default_conf, update, mocker) -> None:
+async def test_blacklist_static(default_conf, update, mocker) -> None:
 
     telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf)
 
-    telegram._blacklist(update=update, context=MagicMock())
+    await telegram._blacklist(update=update, context=MagicMock())
     assert msg_mock.call_count == 1
     assert ("Blacklist contains 2 pairs\n`DOGE/BTC, HOT/BTC`"
             in msg_mock.call_args_list[0][0][0])
@@ -1549,7 +1621,7 @@ def test_blacklist_static(default_conf, update, mocker) -> None:
     # /blacklist ETH/BTC
     context = MagicMock()
     context.args = ["ETH/BTC"]
-    telegram._blacklist(update=update, context=context)
+    await telegram._blacklist(update=update, context=context)
     assert msg_mock.call_count == 1
     assert ("Blacklist contains 3 pairs\n`DOGE/BTC, HOT/BTC, ETH/BTC`"
             in msg_mock.call_args_list[0][0][0])
@@ -1558,7 +1630,7 @@ def test_blacklist_static(default_conf, update, mocker) -> None:
     msg_mock.reset_mock()
     context = MagicMock()
     context.args = ["XRP/.*"]
-    telegram._blacklist(update=update, context=context)
+    await telegram._blacklist(update=update, context=context)
     assert msg_mock.call_count == 1
 
     assert ("Blacklist contains 4 pairs\n`DOGE/BTC, HOT/BTC, ETH/BTC, XRP/.*`"
@@ -1567,13 +1639,13 @@ def test_blacklist_static(default_conf, update, mocker) -> None:
 
     msg_mock.reset_mock()
     context.args = ["DOGE/BTC"]
-    telegram._blacklist_delete(update=update, context=context)
+    await telegram._blacklist_delete(update=update, context=context)
     assert msg_mock.call_count == 1
     assert ("Blacklist contains 3 pairs\n`HOT/BTC, ETH/BTC, XRP/.*`"
             in msg_mock.call_args_list[0][0][0])
 
 
-def test_telegram_logs(default_conf, update, mocker) -> None:
+async def test_telegram_logs(default_conf, update, mocker) -> None:
     mocker.patch.multiple(
         'freqtrade.rpc.telegram.Telegram',
         _init=MagicMock(),
@@ -1584,13 +1656,13 @@ def test_telegram_logs(default_conf, update, mocker) -> None:
 
     context = MagicMock()
     context.args = []
-    telegram._logs(update=update, context=context)
+    await telegram._logs(update=update, context=context)
     assert msg_mock.call_count == 1
     assert "freqtrade\\.rpc\\.telegram" in msg_mock.call_args_list[0][0][0]
 
     msg_mock.reset_mock()
     context.args = ["1"]
-    telegram._logs(update=update, context=context)
+    await telegram._logs(update=update, context=context)
     assert msg_mock.call_count == 1
 
     msg_mock.reset_mock()
@@ -1598,22 +1670,22 @@ def test_telegram_logs(default_conf, update, mocker) -> None:
     mocker.patch('freqtrade.rpc.telegram.MAX_MESSAGE_LENGTH', 200)
     context = MagicMock()
     context.args = []
-    telegram._logs(update=update, context=context)
+    await telegram._logs(update=update, context=context)
     # Called at least 2 times. Exact times will change with unrelated changes to setup messages
     # Therefore we don't test for this explicitly.
     assert msg_mock.call_count >= 2
 
 
-def test_edge_disabled(default_conf, update, mocker) -> None:
+async def test_edge_disabled(default_conf, update, mocker) -> None:
 
     telegram, _, msg_mock = get_telegram_testobject(mocker, default_conf)
 
-    telegram._edge(update=update, context=MagicMock())
+    await telegram._edge(update=update, context=MagicMock())
     assert msg_mock.call_count == 1
     assert "Edge is not enabled." in msg_mock.call_args_list[0][0][0]
 
 
-def test_edge_enabled(edge_conf, update, mocker) -> None:
+async def test_edge_enabled(edge_conf, update, mocker) -> None:
     mocker.patch('freqtrade.edge.Edge._cached_pairs', mocker.PropertyMock(
         return_value={
             'E/F': PairInfo(-0.01, 0.66, 3.71, 0.50, 1.71, 10, 60),
@@ -1622,7 +1694,7 @@ def test_edge_enabled(edge_conf, update, mocker) -> None:
 
     telegram, _, msg_mock = get_telegram_testobject(mocker, edge_conf)
 
-    telegram._edge(update=update, context=MagicMock())
+    await telegram._edge(update=update, context=MagicMock())
     assert msg_mock.call_count == 1
     assert '<b>Edge only validated following pairs:</b>\n<pre>' in msg_mock.call_args_list[0][0][0]
     assert 'Pair      Winrate    Expectancy    Stoploss' in msg_mock.call_args_list[0][0][0]
@@ -1631,7 +1703,7 @@ def test_edge_enabled(edge_conf, update, mocker) -> None:
 
     mocker.patch('freqtrade.edge.Edge._cached_pairs', mocker.PropertyMock(
         return_value={}))
-    telegram._edge(update=update, context=MagicMock())
+    await telegram._edge(update=update, context=MagicMock())
     assert msg_mock.call_count == 1
     assert '<b>Edge only validated following pairs:</b>' in msg_mock.call_args_list[0][0][0]
     assert 'Winrate' not in msg_mock.call_args_list[0][0][0]
@@ -1640,20 +1712,20 @@ def test_edge_enabled(edge_conf, update, mocker) -> None:
 @pytest.mark.parametrize('is_short,regex_pattern',
                          [(True, r"just now[ ]*XRP\/BTC \(#3\)  -1.00% \("),
                           (False, r"just now[ ]*XRP\/BTC \(#3\)  1.00% \(")])
-def test_telegram_trades(mocker, update, default_conf, fee, is_short, regex_pattern):
+async def test_telegram_trades(mocker, update, default_conf, fee, is_short, regex_pattern):
 
     telegram, _, msg_mock = get_telegram_testobject(mocker, default_conf)
 
     context = MagicMock()
     context.args = []
 
-    telegram._trades(update=update, context=context)
+    await telegram._trades(update=update, context=context)
     assert "<b>0 recent trades</b>:" in msg_mock.call_args_list[0][0][0]
     assert "<pre>" not in msg_mock.call_args_list[0][0][0]
     msg_mock.reset_mock()
 
     context.args = ['hello']
-    telegram._trades(update=update, context=context)
+    await telegram._trades(update=update, context=context)
     assert "<b>0 recent trades</b>:" in msg_mock.call_args_list[0][0][0]
     assert "<pre>" not in msg_mock.call_args_list[0][0][0]
     msg_mock.reset_mock()
@@ -1662,7 +1734,7 @@ def test_telegram_trades(mocker, update, default_conf, fee, is_short, regex_patt
 
     context = MagicMock()
     context.args = [5]
-    telegram._trades(update=update, context=context)
+    await telegram._trades(update=update, context=context)
     msg_mock.call_count == 1
     assert "2 recent trades</b>:" in msg_mock.call_args_list[0][0][0]
     assert "Profit (" in msg_mock.call_args_list[0][0][0]
@@ -1672,13 +1744,13 @@ def test_telegram_trades(mocker, update, default_conf, fee, is_short, regex_patt
 
 
 @pytest.mark.parametrize('is_short', [True, False])
-def test_telegram_delete_trade(mocker, update, default_conf, fee, is_short):
+async def test_telegram_delete_trade(mocker, update, default_conf, fee, is_short):
 
     telegram, _, msg_mock = get_telegram_testobject(mocker, default_conf)
     context = MagicMock()
     context.args = []
 
-    telegram._delete_trade(update=update, context=context)
+    await telegram._delete_trade(update=update, context=context)
     assert "Trade-id not set." in msg_mock.call_args_list[0][0][0]
 
     msg_mock.reset_mock()
@@ -1686,14 +1758,33 @@ def test_telegram_delete_trade(mocker, update, default_conf, fee, is_short):
 
     context = MagicMock()
     context.args = [1]
-    telegram._delete_trade(update=update, context=context)
+    await telegram._delete_trade(update=update, context=context)
     msg_mock.call_count == 1
     assert "Deleted trade 1." in msg_mock.call_args_list[0][0][0]
     assert "Please make sure to take care of this asset" in msg_mock.call_args_list[0][0][0]
 
 
 @pytest.mark.parametrize('is_short', [True, False])
-def test_telegram_delete_open_order(mocker, update, default_conf, fee, is_short, ticker):
+async def test_telegram_reload_trade_from_exchange(mocker, update, default_conf, fee, is_short):
+
+    telegram, _, msg_mock = get_telegram_testobject(mocker, default_conf)
+    context = MagicMock()
+    context.args = []
+
+    await telegram._reload_trade_from_exchange(update=update, context=context)
+    assert "Trade-id not set." in msg_mock.call_args_list[0][0][0]
+
+    msg_mock.reset_mock()
+    create_mock_trades(fee, is_short=is_short)
+
+    context.args = [5]
+
+    await telegram._reload_trade_from_exchange(update=update, context=context)
+    assert "Status: `Reloaded from orders from exchange`" in msg_mock.call_args_list[0][0][0]
+
+
+@pytest.mark.parametrize('is_short', [True, False])
+async def test_telegram_delete_open_order(mocker, update, default_conf, fee, is_short, ticker):
 
     mocker.patch.multiple(
         EXMS,
@@ -1703,7 +1794,7 @@ def test_telegram_delete_open_order(mocker, update, default_conf, fee, is_short,
     context = MagicMock()
     context.args = []
 
-    telegram._cancel_open_order(update=update, context=context)
+    await telegram._cancel_open_order(update=update, context=context)
     assert "Trade-id not set." in msg_mock.call_args_list[0][0][0]
 
     msg_mock.reset_mock()
@@ -1711,7 +1802,7 @@ def test_telegram_delete_open_order(mocker, update, default_conf, fee, is_short,
 
     context = MagicMock()
     context.args = [5]
-    telegram._cancel_open_order(update=update, context=context)
+    await telegram._cancel_open_order(update=update, context=context)
     assert "No open order for trade_id" in msg_mock.call_args_list[0][0][0]
 
     msg_mock.reset_mock()
@@ -1720,43 +1811,43 @@ def test_telegram_delete_open_order(mocker, update, default_conf, fee, is_short,
     mocker.patch(f'{EXMS}.fetch_order', return_value=trade.orders[-1].to_ccxt_object())
     context = MagicMock()
     context.args = [6]
-    telegram._cancel_open_order(update=update, context=context)
+    await telegram._cancel_open_order(update=update, context=context)
     assert msg_mock.call_count == 1
     assert "Open order canceled." in msg_mock.call_args_list[0][0][0]
 
 
-def test_help_handle(default_conf, update, mocker) -> None:
+async def test_help_handle(default_conf, update, mocker) -> None:
     telegram, _, msg_mock = get_telegram_testobject(mocker, default_conf)
 
-    telegram._help(update=update, context=MagicMock())
+    await telegram._help(update=update, context=MagicMock())
     assert msg_mock.call_count == 1
     assert '*/help:* `This help message`' in msg_mock.call_args_list[0][0][0]
 
 
-def test_version_handle(default_conf, update, mocker) -> None:
+async def test_version_handle(default_conf, update, mocker) -> None:
 
     telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf)
 
-    telegram._version(update=update, context=MagicMock())
+    await telegram._version(update=update, context=MagicMock())
     assert msg_mock.call_count == 1
     assert f'*Version:* `{__version__}`' in msg_mock.call_args_list[0][0][0]
 
     msg_mock.reset_mock()
     freqtradebot.strategy.version = lambda: '1.1.1'
 
-    telegram._version(update=update, context=MagicMock())
+    await telegram._version(update=update, context=MagicMock())
     assert msg_mock.call_count == 1
     assert f'*Version:* `{__version__}`' in msg_mock.call_args_list[0][0][0]
     assert '*Strategy version: * `1.1.1`' in msg_mock.call_args_list[0][0][0]
 
 
-def test_show_config_handle(default_conf, update, mocker) -> None:
+async def test_show_config_handle(default_conf, update, mocker) -> None:
 
     default_conf['runmode'] = RunMode.DRY_RUN
 
     telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf)
 
-    telegram._show_config(update=update, context=MagicMock())
+    await telegram._show_config(update=update, context=MagicMock())
     assert msg_mock.call_count == 1
     assert '*Mode:* `{}`'.format('Dry-run') in msg_mock.call_args_list[0][0][0]
     assert '*Exchange:* `binance`' in msg_mock.call_args_list[0][0][0]
@@ -1765,7 +1856,7 @@ def test_show_config_handle(default_conf, update, mocker) -> None:
 
     msg_mock.reset_mock()
     freqtradebot.config['trailing_stop'] = True
-    telegram._show_config(update=update, context=MagicMock())
+    await telegram._show_config(update=update, context=MagicMock())
     assert msg_mock.call_count == 1
     assert '*Mode:* `{}`'.format('Dry-run') in msg_mock.call_args_list[0][0][0]
     assert '*Exchange:* `binance`' in msg_mock.call_args_list[0][0][0]
@@ -1807,7 +1898,7 @@ def test_send_msg_enter_notification(default_conf, mocker, caplog, message_type,
         'current_rate': 1.099e-05,
         'amount': 1333.3333333333335,
         'analyzed_candle': {'open': 1.1, 'high': 2.2, 'low': 1.0, 'close': 1.5},
-        'open_date': arrow.utcnow().shift(hours=-1)
+        'open_date': dt_now() + timedelta(hours=-1)
     }
     telegram, freqtradebot, msg_mock = get_telegram_testobject(mocker, default_conf)
 
@@ -1868,7 +1959,7 @@ def test_send_msg_protection_notification(default_conf, mocker, time_machine) ->
 
     telegram, _, msg_mock = get_telegram_testobject(mocker, default_conf)
     time_machine.move_to("2021-09-01 05:00:00 +00:00")
-    lock = PairLocks.lock_pair('ETH/BTC', arrow.utcnow().shift(minutes=6).datetime, 'randreason')
+    lock = PairLocks.lock_pair('ETH/BTC', dt_now() + timedelta(minutes=6), 'randreason')
     msg = {
         'type': RPCMessageType.PROTECTION_TRIGGER,
     }
@@ -1883,7 +1974,7 @@ def test_send_msg_protection_notification(default_conf, mocker, time_machine) ->
     msg = {
         'type': RPCMessageType.PROTECTION_TRIGGER_GLOBAL,
     }
-    lock = PairLocks.lock_pair('*', arrow.utcnow().shift(minutes=100).datetime, 'randreason')
+    lock = PairLocks.lock_pair('*', dt_now() + timedelta(minutes=100), 'randreason')
     msg.update(lock.to_json())
     telegram.send_msg(msg)
     assert (msg_mock.call_args[0][0] == "*Protection* triggered due to randreason. "
@@ -1914,7 +2005,7 @@ def test_send_msg_entry_fill_notification(default_conf, mocker, message_type, en
         'fiat_currency': 'USD',
         'open_rate': 1.099e-05,
         'amount': 1333.3333333333335,
-        'open_date': arrow.utcnow().shift(hours=-1)
+        'open_date': dt_now() - timedelta(hours=1)
     })
     leverage_text = f'*Leverage:* `{leverage}`\n' if leverage != 1.0 else ''
     assert msg_mock.call_args[0][0] == (
@@ -1941,7 +2032,7 @@ def test_send_msg_entry_fill_notification(default_conf, mocker, message_type, en
         'fiat_currency': 'USD',
         'open_rate': 1.099e-05,
         'amount': 1333.3333333333335,
-        'open_date': arrow.utcnow().shift(hours=-1)
+        'open_date': dt_now() - timedelta(hours=1)
     })
 
     assert msg_mock.call_args[0][0] == (
@@ -1980,8 +2071,8 @@ def test_send_msg_sell_notification(default_conf, mocker) -> None:
             'fiat_currency': 'USD',
             'enter_tag': 'buy_signal1',
             'exit_reason': ExitType.STOP_LOSS.value,
-            'open_date': arrow.utcnow().shift(hours=-1),
-            'close_date': arrow.utcnow(),
+            'open_date': dt_now() - timedelta(hours=1),
+            'close_date': dt_now(),
         })
         assert msg_mock.call_args[0][0] == (
             '\N{WARNING SIGN} *Binance (dry):* Exiting KEY/ETH (#1)\n'
@@ -2016,8 +2107,8 @@ def test_send_msg_sell_notification(default_conf, mocker) -> None:
             'fiat_currency': 'USD',
             'enter_tag': 'buy_signal1',
             'exit_reason': ExitType.STOP_LOSS.value,
-            'open_date': arrow.utcnow().shift(days=-1, hours=-2, minutes=-30),
-            'close_date': arrow.utcnow(),
+            'open_date': dt_now() - timedelta(days=1, hours=2, minutes=30),
+            'close_date': dt_now(),
             'stake_amount': 0.01,
             'sub_trade': True,
         })
@@ -2053,8 +2144,8 @@ def test_send_msg_sell_notification(default_conf, mocker) -> None:
             'stake_currency': 'ETH',
             'enter_tag': 'buy_signal1',
             'exit_reason': ExitType.STOP_LOSS.value,
-            'open_date': arrow.utcnow().shift(days=-1, hours=-2, minutes=-30),
-            'close_date': arrow.utcnow(),
+            'open_date': dt_now() - timedelta(days=1, hours=2, minutes=30),
+            'close_date': dt_now(),
         })
         assert msg_mock.call_args[0][0] == (
             '\N{WARNING SIGN} *Binance (dry):* Exiting KEY/ETH (#1)\n'
@@ -2072,7 +2163,7 @@ def test_send_msg_sell_notification(default_conf, mocker) -> None:
         telegram._rpc._fiat_converter.convert_amount = old_convamount
 
 
-def test_send_msg_sell_cancel_notification(default_conf, mocker) -> None:
+async def test_send_msg_sell_cancel_notification(default_conf, mocker) -> None:
 
     telegram, _, msg_mock = get_telegram_testobject(mocker, default_conf)
 
@@ -2135,8 +2226,8 @@ def test_send_msg_sell_fill_notification(default_conf, mocker, direction,
             'stake_currency': 'ETH',
             'enter_tag': enter_signal,
             'exit_reason': ExitType.STOP_LOSS.value,
-            'open_date': arrow.utcnow().shift(days=-1, hours=-2, minutes=-30),
-            'close_date': arrow.utcnow(),
+            'open_date': dt_now() - timedelta(days=1, hours=2, minutes=30),
+            'close_date': dt_now(),
         })
 
         leverage_text = f'*Leverage:* `{leverage}`\n' if leverage and leverage != 1.0 else ''
@@ -2164,7 +2255,7 @@ def test_send_msg_status_notification(default_conf, mocker) -> None:
     assert msg_mock.call_args[0][0] == '*Status:* `running`'
 
 
-def test_warning_notification(default_conf, mocker) -> None:
+async def test_warning_notification(default_conf, mocker) -> None:
     telegram, _, msg_mock = get_telegram_testobject(mocker, default_conf)
     telegram.send_msg({
         'type': RPCMessageType.WARNING,
@@ -2226,7 +2317,7 @@ def test_send_msg_buy_notification_no_fiat(
         'fiat_currency': None,
         'current_rate': 1.099e-05,
         'amount': 1333.3333333333335,
-        'open_date': arrow.utcnow().shift(hours=-1)
+        'open_date': dt_now() - timedelta(hours=1)
     })
 
     leverage_text = f'*Leverage:* `{leverage}`\n' if leverage and leverage != 1.0 else ''
@@ -2272,8 +2363,8 @@ def test_send_msg_sell_notification_no_fiat(
         'fiat_currency': 'USD',
         'enter_tag': enter_signal,
         'exit_reason': ExitType.STOP_LOSS.value,
-        'open_date': arrow.utcnow().shift(hours=-2, minutes=-35, seconds=-3),
-        'close_date': arrow.utcnow(),
+        'open_date': dt_now() - timedelta(hours=2, minutes=35, seconds=3),
+        'close_date': dt_now(),
     })
 
     leverage_text = f'*Leverage:* `{leverage}`\n' if leverage and leverage != 1.0 else ''
@@ -2309,60 +2400,62 @@ def test__sell_emoji(default_conf, mocker, msg, expected):
     assert telegram._get_sell_emoji(msg) == expected
 
 
-def test_telegram__send_msg(default_conf, mocker, caplog) -> None:
+async def test_telegram__send_msg(default_conf, mocker, caplog) -> None:
     mocker.patch('freqtrade.rpc.telegram.Telegram._init', MagicMock())
     bot = MagicMock()
+    bot.send_message = AsyncMock()
+    bot.edit_message_text = AsyncMock()
     telegram, _, _ = get_telegram_testobject(mocker, default_conf, mock=False)
-    telegram._updater = MagicMock()
-    telegram._updater.bot = bot
+    telegram._app = MagicMock()
+    telegram._app.bot = bot
 
-    telegram._config['telegram']['enabled'] = True
-    telegram._send_msg('test')
+    await telegram._send_msg('test')
     assert len(bot.method_calls) == 1
 
     # Test update
     query = MagicMock()
-    telegram._send_msg('test', callback_path="DeadBeef", query=query, reload_able=True)
-    edit_message_text = telegram._updater.bot.edit_message_text
+    await telegram._send_msg('test', callback_path="DeadBeef", query=query, reload_able=True)
+    edit_message_text = telegram._app.bot.edit_message_text
     assert edit_message_text.call_count == 1
     assert "Updated: " in edit_message_text.call_args_list[0][1]['text']
 
-    telegram._updater.bot.edit_message_text = MagicMock(side_effect=BadRequest("not modified"))
-    telegram._send_msg('test', callback_path="DeadBeef", query=query)
-    assert telegram._updater.bot.edit_message_text.call_count == 1
+    telegram._app.bot.edit_message_text = AsyncMock(side_effect=BadRequest("not modified"))
+    await telegram._send_msg('test', callback_path="DeadBeef", query=query)
+    assert telegram._app.bot.edit_message_text.call_count == 1
     assert not log_has_re(r"TelegramError: .*", caplog)
 
-    telegram._updater.bot.edit_message_text = MagicMock(side_effect=BadRequest(""))
-    telegram._send_msg('test2', callback_path="DeadBeef", query=query)
-    assert telegram._updater.bot.edit_message_text.call_count == 1
+    telegram._app.bot.edit_message_text = AsyncMock(side_effect=BadRequest(""))
+    await telegram._send_msg('test2', callback_path="DeadBeef", query=query)
+    assert telegram._app.bot.edit_message_text.call_count == 1
     assert log_has_re(r"TelegramError: .*", caplog)
 
-    telegram._updater.bot.edit_message_text = MagicMock(side_effect=TelegramError("DeadBEEF"))
-    telegram._send_msg('test3', callback_path="DeadBeef", query=query)
+    telegram._app.bot.edit_message_text = AsyncMock(side_effect=TelegramError("DeadBEEF"))
+    await telegram._send_msg('test3', callback_path="DeadBeef", query=query)
 
     assert log_has_re(r"TelegramError: DeadBEEF! Giving up.*", caplog)
 
 
-def test__send_msg_network_error(default_conf, mocker, caplog) -> None:
+async def test__send_msg_network_error(default_conf, mocker, caplog) -> None:
     mocker.patch('freqtrade.rpc.telegram.Telegram._init', MagicMock())
     bot = MagicMock()
     bot.send_message = MagicMock(side_effect=NetworkError('Oh snap'))
     telegram, _, _ = get_telegram_testobject(mocker, default_conf, mock=False)
-    telegram._updater = MagicMock()
-    telegram._updater.bot = bot
+    telegram._app = MagicMock()
+    telegram._app.bot = bot
 
     telegram._config['telegram']['enabled'] = True
-    telegram._send_msg('test')
+    await telegram._send_msg('test')
 
     # Bot should've tried to send it twice
     assert len(bot.method_calls) == 2
     assert log_has('Telegram NetworkError: Oh snap! Trying one more time.', caplog)
 
 
-def test__send_msg_keyboard(default_conf, mocker, caplog) -> None:
+@pytest.mark.filterwarnings("ignore:.*ChatPermissions")
+async def test__send_msg_keyboard(default_conf, mocker, caplog) -> None:
     mocker.patch('freqtrade.rpc.telegram.Telegram._init', MagicMock())
     bot = MagicMock()
-    bot.send_message = MagicMock()
+    bot.send_message = AsyncMock()
     freqtradebot = get_patched_freqtradebot(mocker, default_conf)
     rpc = RPC(freqtradebot)
 
@@ -2378,14 +2471,14 @@ def test__send_msg_keyboard(default_conf, mocker, caplog) -> None:
 
     def init_telegram(freqtradebot):
         telegram = Telegram(rpc, default_conf)
-        telegram._updater = MagicMock()
-        telegram._updater.bot = bot
+        telegram._app = MagicMock()
+        telegram._app.bot = bot
         return telegram
 
     # no keyboard in config -> default keyboard
     freqtradebot.config['telegram']['enabled'] = True
     telegram = init_telegram(freqtradebot)
-    telegram._send_msg('test')
+    await telegram._send_msg('test')
     used_keyboard = bot.send_message.call_args[1]['reply_markup']
     assert used_keyboard == default_keyboard
 
@@ -2402,7 +2495,7 @@ def test__send_msg_keyboard(default_conf, mocker, caplog) -> None:
     freqtradebot.config['telegram']['enabled'] = True
     freqtradebot.config['telegram']['keyboard'] = custom_keys_list
     telegram = init_telegram(freqtradebot)
-    telegram._send_msg('test')
+    await telegram._send_msg('test')
     used_keyboard = bot.send_message.call_args[1]['reply_markup']
     assert used_keyboard == custom_keyboard
     assert log_has("using custom keyboard from config.json: "
@@ -2410,13 +2503,14 @@ def test__send_msg_keyboard(default_conf, mocker, caplog) -> None:
                    "'/start', '/reload_config', '/help']]", caplog)
 
 
-def test_change_market_direction(default_conf, mocker, update) -> None:
+async def test_change_market_direction(default_conf, mocker, update) -> None:
     telegram, _, msg_mock = get_telegram_testobject(mocker, default_conf)
     assert telegram._rpc._freqtrade.strategy.market_direction == MarketDirection.NONE
     context = MagicMock()
     context.args = ["long"]
-    telegram._changemarketdir(update, context)
+    await telegram._changemarketdir(update, context)
     assert telegram._rpc._freqtrade.strategy.market_direction == MarketDirection.LONG
     context = MagicMock()
     context.args = ["invalid"]
+    await telegram._changemarketdir(update, context)
     assert telegram._rpc._freqtrade.strategy.market_direction == MarketDirection.LONG
diff --git a/tests/rpc/test_rpc_webhook.py b/tests/rpc/test_rpc_webhook.py
index f55582107..d0a0f5b1e 100644
--- a/tests/rpc/test_rpc_webhook.py
+++ b/tests/rpc/test_rpc_webhook.py
@@ -17,6 +17,10 @@ def get_webhook_dict() -> dict:
         "enabled": True,
         "url": "https://maker.ifttt.com/trigger/freqtrade_test/with/key/c764udvJ5jfSlswVRukZZ2/",
         "webhookentry": {
+            # Intentionally broken, as "entry" should have priority.
+            "value1": "Buying {pair55555}",
+        },
+        "entry": {
             "value1": "Buying {pair}",
             "value2": "limit {limit:8f}",
             "value3": "{stake_amount:8f} {stake_currency}",
@@ -89,15 +93,15 @@ def test_send_msg_webhook(default_conf, mocker):
     webhook.send_msg(msg=msg)
     assert msg_mock.call_count == 1
     assert (msg_mock.call_args[0][0]["value1"] ==
-            default_conf["webhook"]["webhookentry"]["value1"].format(**msg))
+            default_conf["webhook"]["entry"]["value1"].format(**msg))
     assert (msg_mock.call_args[0][0]["value2"] ==
-            default_conf["webhook"]["webhookentry"]["value2"].format(**msg))
+            default_conf["webhook"]["entry"]["value2"].format(**msg))
     assert (msg_mock.call_args[0][0]["value3"] ==
-            default_conf["webhook"]["webhookentry"]["value3"].format(**msg))
+            default_conf["webhook"]["entry"]["value3"].format(**msg))
     assert (msg_mock.call_args[0][0]["value4"] ==
-            default_conf["webhook"]["webhookentry"]["value4"].format(**msg))
+            default_conf["webhook"]["entry"]["value4"].format(**msg))
     assert (msg_mock.call_args[0][0]["value5"] ==
-            default_conf["webhook"]["webhookentry"]["value5"].format(**msg))
+            default_conf["webhook"]["entry"]["value5"].format(**msg))
     # Test short
     msg_mock.reset_mock()
 
@@ -116,15 +120,15 @@ def test_send_msg_webhook(default_conf, mocker):
     webhook.send_msg(msg=msg)
     assert msg_mock.call_count == 1
     assert (msg_mock.call_args[0][0]["value1"] ==
-            default_conf["webhook"]["webhookentry"]["value1"].format(**msg))
+            default_conf["webhook"]["entry"]["value1"].format(**msg))
     assert (msg_mock.call_args[0][0]["value2"] ==
-            default_conf["webhook"]["webhookentry"]["value2"].format(**msg))
+            default_conf["webhook"]["entry"]["value2"].format(**msg))
     assert (msg_mock.call_args[0][0]["value3"] ==
-            default_conf["webhook"]["webhookentry"]["value3"].format(**msg))
+            default_conf["webhook"]["entry"]["value3"].format(**msg))
     assert (msg_mock.call_args[0][0]["value4"] ==
-            default_conf["webhook"]["webhookentry"]["value4"].format(**msg))
+            default_conf["webhook"]["entry"]["value4"].format(**msg))
     assert (msg_mock.call_args[0][0]["value5"] ==
-            default_conf["webhook"]["webhookentry"]["value5"].format(**msg))
+            default_conf["webhook"]["entry"]["value5"].format(**msg))
     # Test buy cancel
     msg_mock.reset_mock()
 
@@ -328,6 +332,7 @@ def test_send_msg_webhook(default_conf, mocker):
 
 def test_exception_send_msg(default_conf, mocker, caplog):
     default_conf["webhook"] = get_webhook_dict()
+    del default_conf["webhook"]["entry"]
     del default_conf["webhook"]["webhookentry"]
 
     webhook = Webhook(RPC(get_patched_freqtradebot(mocker, default_conf)), default_conf)
diff --git a/tests/strategy/test_default_strategy.py b/tests/strategy/test_default_strategy.py
index cb3d61e89..5f41177eb 100644
--- a/tests/strategy/test_default_strategy.py
+++ b/tests/strategy/test_default_strategy.py
@@ -1,4 +1,4 @@
-from datetime import datetime
+from datetime import datetime, timezone
 
 import pytest
 from pandas import DataFrame
@@ -43,12 +43,12 @@ def test_strategy_test_v3(dataframe_1m, fee, is_short, side):
 
     assert strategy.confirm_trade_entry(pair='ETH/BTC', order_type='limit', amount=0.1,
                                         rate=20000, time_in_force='gtc',
-                                        current_time=datetime.utcnow(),
+                                        current_time=datetime.now(timezone.utc),
                                         side=side, entry_tag=None) is True
     assert strategy.confirm_trade_exit(pair='ETH/BTC', trade=trade, order_type='limit', amount=0.1,
                                        rate=20000, time_in_force='gtc', exit_reason='roi',
                                        sell_reason='roi',
-                                       current_time=datetime.utcnow(),
+                                       current_time=datetime.now(timezone.utc),
                                        side=side) is True
 
     assert strategy.custom_stoploss(pair='ETH/BTC', trade=trade, current_time=datetime.now(),
diff --git a/tests/strategy/test_interface.py b/tests/strategy/test_interface.py
index 204fa996d..8a609cf30 100644
--- a/tests/strategy/test_interface.py
+++ b/tests/strategy/test_interface.py
@@ -4,7 +4,6 @@ from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from unittest.mock import MagicMock
 
-import arrow
 import pytest
 from pandas import DataFrame
 
@@ -22,6 +21,7 @@ from freqtrade.strategy.hyper import detect_parameters
 from freqtrade.strategy.parameters import (BaseParameter, BooleanParameter, CategoricalParameter,
                                            DecimalParameter, IntParameter, RealParameter)
 from freqtrade.strategy.strategy_wrapper import strategy_safe_wrapper
+from freqtrade.util import dt_now
 from tests.conftest import (CURRENT_TEST_STRATEGY, TRADE_SIDES, create_mock_trades, log_has,
                             log_has_re)
 
@@ -34,7 +34,7 @@ _STRATEGY.dp = DataProvider({}, None, None)
 
 
 def test_returns_latest_signal(ohlcv_history):
-    ohlcv_history.loc[1, 'date'] = arrow.utcnow()
+    ohlcv_history.loc[1, 'date'] = dt_now()
     # Take a copy to correctly modify the call
     mocked_history = ohlcv_history.copy()
     mocked_history['enter_long'] = 0
@@ -159,7 +159,7 @@ def test_get_signal_exception_valueerror(mocker, caplog, ohlcv_history):
 def test_get_signal_old_dataframe(default_conf, mocker, caplog, ohlcv_history):
     # default_conf defines a 5m interval. we check interval * 2 + 5m
     # this is necessary as the last candle is removed (partial candles) by default
-    ohlcv_history.loc[1, 'date'] = arrow.utcnow().shift(minutes=-16)
+    ohlcv_history.loc[1, 'date'] = dt_now() - timedelta(minutes=16)
     # Take a copy to correctly modify the call
     mocked_history = ohlcv_history.copy()
     mocked_history['exit_long'] = 0
@@ -180,7 +180,7 @@ def test_get_signal_old_dataframe(default_conf, mocker, caplog, ohlcv_history):
 def test_get_signal_no_sell_column(default_conf, mocker, caplog, ohlcv_history):
     # default_conf defines a 5m interval. we check interval * 2 + 5m
     # this is necessary as the last candle is removed (partial candles) by default
-    ohlcv_history.loc[1, 'date'] = arrow.utcnow()
+    ohlcv_history.loc[1, 'date'] = dt_now()
     # Take a copy to correctly modify the call
     mocked_history = ohlcv_history.copy()
     # Intentionally don't set sell column
@@ -224,7 +224,7 @@ def test_ignore_expired_candle(default_conf):
 
 
 def test_assert_df_raise(mocker, caplog, ohlcv_history):
-    ohlcv_history.loc[1, 'date'] = arrow.utcnow().shift(minutes=-16)
+    ohlcv_history.loc[1, 'date'] = dt_now() - timedelta(minutes=16)
     # Take a copy to correctly modify the call
     mocked_history = ohlcv_history.copy()
     mocked_history['sell'] = 0
@@ -323,21 +323,21 @@ def test_min_roi_reached(default_conf, fee) -> None:
             pair='ETH/BTC',
             stake_amount=0.001,
             amount=5,
-            open_date=arrow.utcnow().shift(hours=-1).datetime,
+            open_date=dt_now() - timedelta(hours=1),
             fee_open=fee.return_value,
             fee_close=fee.return_value,
             exchange='binance',
             open_rate=1,
         )
 
-        assert not strategy.min_roi_reached(trade, 0.02, arrow.utcnow().shift(minutes=-56).datetime)
-        assert strategy.min_roi_reached(trade, 0.12, arrow.utcnow().shift(minutes=-56).datetime)
+        assert not strategy.min_roi_reached(trade, 0.02, dt_now() - timedelta(minutes=56))
+        assert strategy.min_roi_reached(trade, 0.12, dt_now() - timedelta(minutes=56))
 
-        assert not strategy.min_roi_reached(trade, 0.04, arrow.utcnow().shift(minutes=-39).datetime)
-        assert strategy.min_roi_reached(trade, 0.06, arrow.utcnow().shift(minutes=-39).datetime)
+        assert not strategy.min_roi_reached(trade, 0.04, dt_now() - timedelta(minutes=39))
+        assert strategy.min_roi_reached(trade, 0.06, dt_now() - timedelta(minutes=39))
 
-        assert not strategy.min_roi_reached(trade, -0.01, arrow.utcnow().shift(minutes=-1).datetime)
-        assert strategy.min_roi_reached(trade, 0.02, arrow.utcnow().shift(minutes=-1).datetime)
+        assert not strategy.min_roi_reached(trade, -0.01, dt_now() - timedelta(minutes=1))
+        assert strategy.min_roi_reached(trade, 0.02, dt_now() - timedelta(minutes=1))
 
 
 def test_min_roi_reached2(default_conf, fee) -> None:
@@ -361,25 +361,25 @@ def test_min_roi_reached2(default_conf, fee) -> None:
             pair='ETH/BTC',
             stake_amount=0.001,
             amount=5,
-            open_date=arrow.utcnow().shift(hours=-1).datetime,
+            open_date=dt_now() - timedelta(hours=1),
             fee_open=fee.return_value,
             fee_close=fee.return_value,
             exchange='binance',
             open_rate=1,
         )
 
-        assert not strategy.min_roi_reached(trade, 0.02, arrow.utcnow().shift(minutes=-56).datetime)
-        assert strategy.min_roi_reached(trade, 0.12, arrow.utcnow().shift(minutes=-56).datetime)
+        assert not strategy.min_roi_reached(trade, 0.02, dt_now() - timedelta(minutes=56))
+        assert strategy.min_roi_reached(trade, 0.12, dt_now() - timedelta(minutes=56))
 
-        assert not strategy.min_roi_reached(trade, 0.04, arrow.utcnow().shift(minutes=-39).datetime)
-        assert strategy.min_roi_reached(trade, 0.071, arrow.utcnow().shift(minutes=-39).datetime)
+        assert not strategy.min_roi_reached(trade, 0.04, dt_now() - timedelta(minutes=39))
+        assert strategy.min_roi_reached(trade, 0.071, dt_now() - timedelta(minutes=39))
 
-        assert not strategy.min_roi_reached(trade, 0.04, arrow.utcnow().shift(minutes=-26).datetime)
-        assert strategy.min_roi_reached(trade, 0.06, arrow.utcnow().shift(minutes=-26).datetime)
+        assert not strategy.min_roi_reached(trade, 0.04, dt_now() - timedelta(minutes=26))
+        assert strategy.min_roi_reached(trade, 0.06, dt_now() - timedelta(minutes=26))
 
         # Should not trigger with 20% profit since after 55 minutes only 30% is active.
-        assert not strategy.min_roi_reached(trade, 0.20, arrow.utcnow().shift(minutes=-2).datetime)
-        assert strategy.min_roi_reached(trade, 0.31, arrow.utcnow().shift(minutes=-2).datetime)
+        assert not strategy.min_roi_reached(trade, 0.20, dt_now() - timedelta(minutes=2))
+        assert strategy.min_roi_reached(trade, 0.31, dt_now() - timedelta(minutes=2))
 
 
 def test_min_roi_reached3(default_conf, fee) -> None:
@@ -395,25 +395,25 @@ def test_min_roi_reached3(default_conf, fee) -> None:
         pair='ETH/BTC',
         stake_amount=0.001,
         amount=5,
-        open_date=arrow.utcnow().shift(hours=-1).datetime,
+        open_date=dt_now() - timedelta(hours=1),
         fee_open=fee.return_value,
         fee_close=fee.return_value,
         exchange='binance',
         open_rate=1,
     )
 
-    assert not strategy.min_roi_reached(trade, 0.02, arrow.utcnow().shift(minutes=-56).datetime)
-    assert not strategy.min_roi_reached(trade, 0.12, arrow.utcnow().shift(minutes=-56).datetime)
+    assert not strategy.min_roi_reached(trade, 0.02, dt_now() - timedelta(minutes=56))
+    assert not strategy.min_roi_reached(trade, 0.12, dt_now() - timedelta(minutes=56))
 
-    assert not strategy.min_roi_reached(trade, 0.04, arrow.utcnow().shift(minutes=-39).datetime)
-    assert strategy.min_roi_reached(trade, 0.071, arrow.utcnow().shift(minutes=-39).datetime)
+    assert not strategy.min_roi_reached(trade, 0.04, dt_now() - timedelta(minutes=39))
+    assert strategy.min_roi_reached(trade, 0.071, dt_now() - timedelta(minutes=39))
 
-    assert not strategy.min_roi_reached(trade, 0.04, arrow.utcnow().shift(minutes=-26).datetime)
-    assert strategy.min_roi_reached(trade, 0.06, arrow.utcnow().shift(minutes=-26).datetime)
+    assert not strategy.min_roi_reached(trade, 0.04, dt_now() - timedelta(minutes=26))
+    assert strategy.min_roi_reached(trade, 0.06, dt_now() - timedelta(minutes=26))
 
     # Should not trigger with 20% profit since after 55 minutes only 30% is active.
-    assert not strategy.min_roi_reached(trade, 0.20, arrow.utcnow().shift(minutes=-2).datetime)
-    assert strategy.min_roi_reached(trade, 0.31, arrow.utcnow().shift(minutes=-2).datetime)
+    assert not strategy.min_roi_reached(trade, 0.20, dt_now() - timedelta(minutes=2))
+    assert strategy.min_roi_reached(trade, 0.31, dt_now() - timedelta(minutes=2))
 
 
 @pytest.mark.parametrize(
@@ -449,7 +449,7 @@ def test_ft_stoploss_reached(default_conf, fee, profit, adjusted, expected, liq,
         pair='ETH/BTC',
         stake_amount=0.01,
         amount=1,
-        open_date=arrow.utcnow().shift(hours=-1).datetime,
+        open_date=dt_now() - timedelta(hours=1),
         fee_open=fee.return_value,
         fee_close=fee.return_value,
         exchange='binance',
@@ -464,7 +464,7 @@ def test_ft_stoploss_reached(default_conf, fee, profit, adjusted, expected, liq,
     if custom_stop:
         strategy.custom_stoploss = custom_stop
 
-    now = arrow.utcnow().datetime
+    now = dt_now()
     current_rate = trade.open_rate * (1 + profit)
     sl_flag = strategy.ft_stoploss_reached(current_rate=current_rate, trade=trade,
                                            current_time=now, current_profit=profit,
@@ -498,14 +498,14 @@ def test_custom_exit(default_conf, fee, caplog) -> None:
         pair='ETH/BTC',
         stake_amount=0.01,
         amount=1,
-        open_date=arrow.utcnow().shift(hours=-1).datetime,
+        open_date=dt_now() - timedelta(hours=1),
         fee_open=fee.return_value,
         fee_close=fee.return_value,
         exchange='binance',
         open_rate=1,
     )
 
-    now = arrow.utcnow().datetime
+    now = dt_now()
     res = strategy.should_exit(trade, 1, now,
                                enter=False, exit_=False,
                                low=None, high=None)
@@ -547,13 +547,13 @@ def test_should_sell(default_conf, fee) -> None:
         pair='ETH/BTC',
         stake_amount=0.01,
         amount=1,
-        open_date=arrow.utcnow().shift(hours=-1).datetime,
+        open_date=dt_now() - timedelta(hours=1),
         fee_open=fee.return_value,
         fee_close=fee.return_value,
         exchange='binance',
         open_rate=1,
     )
-    now = arrow.utcnow().datetime
+    now = dt_now()
     res = strategy.should_exit(trade, 1, now,
                                enter=False, exit_=False,
                                low=None, high=None)
@@ -728,7 +728,7 @@ def test_is_pair_locked(default_conf):
 
     pair = 'ETH/BTC'
     assert not strategy.is_pair_locked(pair)
-    strategy.lock_pair(pair, arrow.now(timezone.utc).shift(minutes=4).datetime)
+    strategy.lock_pair(pair, dt_now() + timedelta(minutes=4))
     # ETH/BTC locked for 4 minutes
     assert strategy.is_pair_locked(pair)
 
@@ -746,7 +746,7 @@ def test_is_pair_locked(default_conf):
 
     # Lock with reason
     reason = "TestLockR"
-    strategy.lock_pair(pair, arrow.now(timezone.utc).shift(minutes=4).datetime, reason)
+    strategy.lock_pair(pair, dt_now() + timedelta(minutes=4), reason)
     assert strategy.is_pair_locked(pair)
     strategy.unlock_reason(reason)
     assert not strategy.is_pair_locked(pair)
diff --git a/tests/test_configuration.py b/tests/test_configuration.py
index c445b989d..5b09abbd3 100644
--- a/tests/test_configuration.py
+++ b/tests/test_configuration.py
@@ -1271,7 +1271,7 @@ def test_pairlist_resolving_with_config_pl_not_exists(mocker, default_conf):
         configuration.get_config()
 
 
-def test_pairlist_resolving_fallback(mocker):
+def test_pairlist_resolving_fallback(mocker, tmpdir):
     mocker.patch.object(Path, "exists", MagicMock(return_value=True))
     mocker.patch.object(Path, "open", MagicMock(return_value=MagicMock()))
     mocker.patch("freqtrade.configuration.configuration.load_file",
@@ -1290,7 +1290,7 @@ def test_pairlist_resolving_fallback(mocker):
 
     assert config['pairs'] == ['ETH/BTC', 'XRP/BTC']
     assert config['exchange']['name'] == 'binance'
-    assert config['datadir'] == Path.cwd() / "user_data/data/binance"
+    assert config['datadir'] == Path(tmpdir) / "user_data/data/binance"
 
 
 @pytest.mark.parametrize("setting", [
diff --git a/tests/test_freqtradebot.py b/tests/test_freqtradebot.py
index 7bded0f82..71f494372 100644
--- a/tests/test_freqtradebot.py
+++ b/tests/test_freqtradebot.py
@@ -4,10 +4,10 @@
 import logging
 import time
 from copy import deepcopy
+from datetime import timedelta
 from typing import List
 from unittest.mock import ANY, MagicMock, PropertyMock, patch
 
-import arrow
 import pytest
 from pandas import DataFrame
 from sqlalchemy import select
@@ -22,6 +22,7 @@ from freqtrade.freqtradebot import FreqtradeBot
 from freqtrade.persistence import Order, PairLocks, Trade
 from freqtrade.persistence.models import PairLock
 from freqtrade.plugins.protections.iprotection import ProtectionReturn
+from freqtrade.util.datetime_helpers import dt_now, dt_utc
 from freqtrade.worker import Worker
 from tests.conftest import (EXMS, create_mock_trades, create_mock_trades_usdt,
                             get_patched_freqtradebot, get_patched_worker, log_has, log_has_re,
@@ -121,7 +122,7 @@ def test_order_dict(default_conf_usdt, mocker, runmode, caplog) -> None:
 
     freqtrade = FreqtradeBot(conf)
     if runmode == RunMode.LIVE:
-        assert not log_has_re(".*stoploss_on_exchange .* dry-run", caplog)
+        assert not log_has_re(r".*stoploss_on_exchange .* dry-run", caplog)
     assert freqtrade.strategy.order_types['stoploss_on_exchange']
 
     caplog.clear()
@@ -136,7 +137,7 @@ def test_order_dict(default_conf_usdt, mocker, runmode, caplog) -> None:
     }
     freqtrade = FreqtradeBot(conf)
     assert not freqtrade.strategy.order_types['stoploss_on_exchange']
-    assert not log_has_re(".*stoploss_on_exchange .* dry-run", caplog)
+    assert not log_has_re(r".*stoploss_on_exchange .* dry-run", caplog)
 
 
 def test_get_trade_stake_amount(default_conf_usdt, mocker) -> None:
@@ -149,6 +150,34 @@ def test_get_trade_stake_amount(default_conf_usdt, mocker) -> None:
     assert result == default_conf_usdt['stake_amount']
 
 
+@pytest.mark.parametrize('runmode', [
+    RunMode.DRY_RUN,
+    RunMode.LIVE
+])
+def test_load_strategy_no_keys(default_conf_usdt, mocker, runmode, caplog) -> None:
+    patch_RPCManager(mocker)
+    patch_exchange(mocker)
+    conf = deepcopy(default_conf_usdt)
+    conf['runmode'] = runmode
+    erm = mocker.patch('freqtrade.freqtradebot.ExchangeResolver.load_exchange')
+
+    freqtrade = FreqtradeBot(conf)
+    strategy_config = freqtrade.strategy.config
+    assert id(strategy_config['exchange']) == id(conf['exchange'])
+    # Keys have been removed and are not passed to the exchange
+    assert strategy_config['exchange']['key'] == ''
+    assert strategy_config['exchange']['secret'] == ''
+
+    assert erm.call_count == 1
+    ex_conf = erm.call_args_list[0][1]['exchange_config']
+    assert id(ex_conf) != id(conf['exchange'])
+    # Keys are still present
+    assert ex_conf['key'] != ''
+    assert ex_conf['key'] == default_conf_usdt['exchange']['key']
+    assert ex_conf['secret'] != ''
+    assert ex_conf['secret'] == default_conf_usdt['exchange']['secret']
+
+
 @pytest.mark.parametrize("amend_last,wallet,max_open,lsamr,expected", [
                         (False, 120, 2, 0.5, [60, None]),
                         (True, 120, 2, 0.5, [60, 58.8]),
@@ -445,7 +474,7 @@ def test_enter_positions_global_pairlock(default_conf_usdt, ticker_usdt, limit_b
     assert not log_has_re(message, caplog)
     caplog.clear()
 
-    PairLocks.lock_pair('*', arrow.utcnow().shift(minutes=20).datetime, 'Just because', side='*')
+    PairLocks.lock_pair('*', dt_now() + timedelta(minutes=20), 'Just because', side='*')
     n = freqtrade.enter_positions()
     assert n == 0
     assert log_has_re(message, caplog)
@@ -466,7 +495,7 @@ def test_handle_protections(mocker, default_conf_usdt, fee, is_short):
 
     freqtrade = get_patched_freqtradebot(mocker, default_conf_usdt)
     freqtrade.protections._protection_handlers[1].global_stop = MagicMock(
-        return_value=ProtectionReturn(True, arrow.utcnow().shift(hours=1).datetime, "asdf"))
+        return_value=ProtectionReturn(True, dt_now() + timedelta(hours=1), "asdf"))
     create_mock_trades(fee, is_short)
     freqtrade.handle_protections('ETC/BTC', '*')
     send_msg_mock = freqtrade.rpc.send_msg
@@ -1262,7 +1291,7 @@ def test_handle_stoploss_on_exchange(mocker, default_conf_usdt, fee, caplog, is_
     }])
     trade.stoploss_order_id = "107"
     trade.is_open = True
-    trade.stoploss_last_update = arrow.utcnow().shift(hours=-1).datetime
+    trade.stoploss_last_update = dt_now() - timedelta(hours=1)
     trade.stop_loss = 24
     trade.exit_reason = None
     trade.orders.append(
@@ -1411,7 +1440,7 @@ def test_handle_stoploss_on_exchange_partial_cancel_here(
     })
     mocker.patch(f'{EXMS}.fetch_stoploss_order', stoploss_order_hit)
     mocker.patch(f'{EXMS}.cancel_stoploss_order_with_result', stoploss_order_cancel)
-    trade.stoploss_last_update = arrow.utcnow().shift(minutes=-10).datetime
+    trade.stoploss_last_update = dt_now() - timedelta(minutes=10)
 
     assert freqtrade.handle_stoploss_on_exchange(trade) is False
     # Canceled Stoploss filled partially ...
@@ -1631,7 +1660,7 @@ def test_handle_stoploss_on_exchange_trailing(
     trade.is_open = True
     trade.open_order_id = None
     trade.stoploss_order_id = '100'
-    trade.stoploss_last_update = arrow.utcnow().shift(minutes=-20).datetime
+    trade.stoploss_last_update = dt_now() - timedelta(minutes=20)
     trade.orders.append(
         Order(
             ft_order_side='stoploss',
@@ -1762,7 +1791,7 @@ def test_handle_stoploss_on_exchange_trailing_error(
     trade.open_order_id = None
     trade.stoploss_order_id = "abcd"
     trade.stop_loss = 0.2
-    trade.stoploss_last_update = arrow.utcnow().shift(minutes=-601).datetime.replace(tzinfo=None)
+    trade.stoploss_last_update = (dt_now() - timedelta(minutes=601)).replace(tzinfo=None)
     trade.is_short = is_short
 
     stoploss_order_hanging = {
@@ -1786,7 +1815,7 @@ def test_handle_stoploss_on_exchange_trailing_error(
     assert stoploss.call_count == 1
 
     # Fail creating stoploss order
-    trade.stoploss_last_update = arrow.utcnow().shift(minutes=-601).datetime
+    trade.stoploss_last_update = dt_now() - timedelta(minutes=601)
     caplog.clear()
     cancel_mock = mocker.patch(f'{EXMS}.cancel_stoploss_order')
     mocker.patch(f'{EXMS}.create_stoploss', side_effect=ExchangeError())
@@ -1875,7 +1904,7 @@ def test_handle_stoploss_on_exchange_custom_stop(
     trade.is_open = True
     trade.open_order_id = None
     trade.stoploss_order_id = '100'
-    trade.stoploss_last_update = arrow.utcnow().shift(minutes=-601).datetime
+    trade.stoploss_last_update = dt_now() - timedelta(minutes=601)
     trade.orders.append(
         Order(
             ft_order_side='stoploss',
@@ -2013,7 +2042,7 @@ def test_tsl_on_exchange_compatible_with_edge(mocker, edge_conf, fee, limit_orde
     trade.is_open = True
     trade.open_order_id = None
     trade.stoploss_order_id = '100'
-    trade.stoploss_last_update = arrow.utcnow().datetime
+    trade.stoploss_last_update = dt_now()
     trade.orders.append(
         Order(
             ft_order_side='stoploss',
@@ -2107,6 +2136,7 @@ def test_enter_positions(mocker, default_conf_usdt, return_value, side_effect,
     assert mock_ct.call_count == len(default_conf_usdt['exchange']['pair_whitelist'])
 
 
+@pytest.mark.usefixtures("init_persistence")
 @pytest.mark.parametrize("is_short", [False, True])
 def test_exit_positions(mocker, default_conf_usdt, limit_order, is_short, caplog) -> None:
     freqtrade = get_patched_freqtradebot(mocker, default_conf_usdt)
@@ -2115,12 +2145,33 @@ def test_exit_positions(mocker, default_conf_usdt, limit_order, is_short, caplog
     mocker.patch(f'{EXMS}.fetch_order', return_value=limit_order[entry_side(is_short)])
     mocker.patch(f'{EXMS}.get_trades_for_order', return_value=[])
 
-    # TODO: should not be magicmock
-    trade = MagicMock()
-    trade.is_short = is_short
-    trade.open_order_id = '123'
-    trade.open_fee = 0.001
+    order_id = '123'
+    trade = Trade(
+            open_order_id=order_id,
+            pair='ETH/USDT',
+            fee_open=0.001,
+            fee_close=0.001,
+            open_rate=0.01,
+            open_date=dt_now(),
+            stake_amount=0.01,
+            amount=11,
+            exchange="binance",
+            is_short=is_short,
+            leverage=1,
+            )
+    trade.orders.append(Order(
+        ft_order_side=entry_side(is_short),
+        price=0.01,
+        ft_pair=trade.pair,
+        ft_amount=trade.amount,
+        ft_price=trade.open_rate,
+        order_id=order_id,
+
+    ))
+    Trade.session.add(trade)
+    Trade.commit()
     trades = [trade]
+    freqtrade.wallets.update()
     n = freqtrade.exit_positions(trades)
     assert n == 0
     # Test amount not modified by fee-logic
@@ -2133,17 +2184,40 @@ def test_exit_positions(mocker, default_conf_usdt, limit_order, is_short, caplog
     assert gra.call_count == 0
 
 
+@pytest.mark.usefixtures("init_persistence")
 @pytest.mark.parametrize("is_short", [False, True])
 def test_exit_positions_exception(mocker, default_conf_usdt, limit_order, caplog, is_short) -> None:
     freqtrade = get_patched_freqtradebot(mocker, default_conf_usdt)
     order = limit_order[entry_side(is_short)]
     mocker.patch(f'{EXMS}.fetch_order', return_value=order)
 
-    # TODO: should not be magicmock
-    trade = MagicMock()
-    trade.is_short = is_short
+    order_id = '123'
+    trade = Trade(
+        open_order_id=order_id,
+        pair='ETH/USDT',
+        fee_open=0.001,
+        fee_close=0.001,
+        open_rate=0.01,
+        open_date=dt_now(),
+        stake_amount=0.01,
+        amount=11,
+        exchange="binance",
+        is_short=is_short,
+        leverage=1,
+    )
+    trade.orders.append(Order(
+        ft_order_side=entry_side(is_short),
+        price=0.01,
+        ft_pair=trade.pair,
+        ft_amount=trade.amount,
+        ft_price=trade.open_rate,
+        order_id=order_id,
+
+    ))
     trade.open_order_id = None
-    trade.pair = 'ETH/USDT'
+    Trade.session.add(trade)
+    Trade.commit()
+    freqtrade.wallets.update()
     trades = [trade]
 
     # Test raise of DependencyException exception
@@ -2173,7 +2247,7 @@ def test_update_trade_state(mocker, default_conf_usdt, limit_order, is_short, ca
         fee_open=0.001,
         fee_close=0.001,
         open_rate=0.01,
-        open_date=arrow.utcnow().datetime,
+        open_date=dt_now(),
         amount=11,
         exchange="binance",
         is_short=is_short,
@@ -2246,7 +2320,7 @@ def test_update_trade_state_withorderdict(
         amount=amount,
         exchange='binance',
         open_rate=2.0,
-        open_date=arrow.utcnow().datetime,
+        open_date=dt_now(),
         fee_open=fee.return_value,
         fee_close=fee.return_value,
         open_order_id=order_id,
@@ -2333,7 +2407,7 @@ def test_update_trade_state_sell(
         open_rate=0.245441,
         fee_open=0.0025,
         fee_close=0.0025,
-        open_date=arrow.utcnow().datetime,
+        open_date=dt_now(),
         open_order_id=open_order['id'],
         is_open=True,
         interest_rate=0.0005,
@@ -2919,8 +2993,8 @@ def test_manage_open_orders_exit_usercustom(
     )
     freqtrade = FreqtradeBot(default_conf_usdt)
 
-    open_trade_usdt.open_date = arrow.utcnow().shift(hours=-5).datetime
-    open_trade_usdt.close_date = arrow.utcnow().shift(minutes=-601).datetime
+    open_trade_usdt.open_date = dt_now() - timedelta(hours=5)
+    open_trade_usdt.close_date = dt_now() - timedelta(minutes=601)
     open_trade_usdt.close_profit_abs = 0.001
 
     Trade.session.add(open_trade_usdt)
@@ -3001,8 +3075,8 @@ def test_manage_open_orders_exit(
     )
     freqtrade = FreqtradeBot(default_conf_usdt)
 
-    open_trade_usdt.open_date = arrow.utcnow().shift(hours=-5).datetime
-    open_trade_usdt.close_date = arrow.utcnow().shift(minutes=-601).datetime
+    open_trade_usdt.open_date = dt_now() - timedelta(hours=5)
+    open_trade_usdt.close_date = dt_now() - timedelta(minutes=601)
     open_trade_usdt.close_profit_abs = 0.001
     open_trade_usdt.is_short = is_short
 
@@ -3042,8 +3116,8 @@ def test_check_handle_cancelled_exit(
     )
     freqtrade = FreqtradeBot(default_conf_usdt)
 
-    open_trade_usdt.open_date = arrow.utcnow().shift(hours=-5).datetime
-    open_trade_usdt.close_date = arrow.utcnow().shift(minutes=-601).datetime
+    open_trade_usdt.open_date = dt_now() - timedelta(hours=5)
+    open_trade_usdt.close_date = dt_now() - timedelta(minutes=601)
     open_trade_usdt.is_short = is_short
 
     Trade.session.add(open_trade_usdt)
@@ -3371,11 +3445,11 @@ def test_handle_cancel_exit_limit(mocker, default_conf_usdt, fee) -> None:
         exchange='binance',
         open_rate=0.245441,
         open_order_id="sell_123456",
-        open_date=arrow.utcnow().shift(days=-2).datetime,
+        open_date=dt_now() - timedelta(days=2),
         fee_open=fee.return_value,
         fee_close=fee.return_value,
         close_rate=0.555,
-        close_date=arrow.utcnow().datetime,
+        close_date=dt_now(),
         exit_reason="sell_reason_whatever",
         stake_amount=0.245441 * 2,
     )
@@ -5392,7 +5466,7 @@ def test_reupdate_enter_order_fees(mocker, default_conf_usdt, fee, caplog, is_sh
         stake_amount=60.0,
         fee_open=fee.return_value,
         fee_close=fee.return_value,
-        open_date=arrow.utcnow().datetime,
+        open_date=dt_now(),
         is_open=True,
         amount=30,
         open_rate=2.0,
@@ -5507,6 +5581,51 @@ def test_handle_insufficient_funds(mocker, default_conf_usdt, fee, is_short, cap
     assert log_has(f"Error updating {order['id']}.", caplog)
 
 
+@pytest.mark.usefixtures("init_persistence")
+@pytest.mark.parametrize("is_short", [False, True])
+def test_handle_onexchange_order(mocker, default_conf_usdt, limit_order, is_short, caplog):
+    freqtrade = get_patched_freqtradebot(mocker, default_conf_usdt)
+    mock_uts = mocker.spy(freqtrade, 'update_trade_state')
+
+    entry_order = limit_order[entry_side(is_short)]
+    exit_order = limit_order[exit_side(is_short)]
+    mock_fo = mocker.patch(f'{EXMS}.fetch_orders', return_value=[
+        entry_order,
+        exit_order,
+    ])
+
+    order_id = entry_order['id']
+
+    trade = Trade(
+            open_order_id=order_id,
+            pair='ETH/USDT',
+            fee_open=0.001,
+            fee_close=0.001,
+            open_rate=entry_order['price'],
+            open_date=dt_now(),
+            stake_amount=entry_order['cost'],
+            amount=entry_order['amount'],
+            exchange="binance",
+            is_short=is_short,
+            leverage=1,
+            )
+
+    trade.orders.append(Order.parse_from_ccxt_object(
+        entry_order, 'ADA/USDT', entry_side(is_short))
+    )
+    Trade.session.add(trade)
+    freqtrade.handle_onexchange_order(trade)
+    assert log_has_re(r"Found previously unknown order .*", caplog)
+    assert mock_uts.call_count == 1
+    assert mock_fo.call_count == 1
+
+    trade = Trade.session.scalars(select(Trade)).first()
+
+    assert len(trade.orders) == 2
+    assert trade.is_open is False
+    assert trade.exit_reason == ExitType.SOLD_ON_EXCHANGE.value
+
+
 def test_get_valid_price(mocker, default_conf_usdt) -> None:
     patch_RPCManager(mocker)
     patch_exchange(mocker)
@@ -5621,9 +5740,9 @@ def test_update_funding_fees(
     default_conf['trading_mode'] = 'futures'
     default_conf['margin_mode'] = 'isolated'
 
-    date_midnight = arrow.get('2021-09-01 00:00:00').datetime
-    date_eight = arrow.get('2021-09-01 08:00:00').datetime
-    date_sixteen = arrow.get('2021-09-01 16:00:00').datetime
+    date_midnight = dt_utc(2021, 9, 1)
+    date_eight = dt_utc(2021, 9, 1, 8)
+    date_sixteen = dt_utc(2021, 9, 1, 16)
     columns = ['date', 'open', 'high', 'low', 'close', 'volume']
     # 16:00 entry is actually never used
     # But should be kept in the test to ensure we're filtering correctly.
@@ -5912,7 +6031,7 @@ def test_position_adjust(mocker, default_conf_usdt, fee) -> None:
         'ft_is_open': False,
         'id': '651',
         'order_id': '651',
-        'datetime': arrow.utcnow().isoformat(),
+        'datetime': dt_now().isoformat(),
     }
 
     mocker.patch(f'{EXMS}.create_order', MagicMock(return_value=closed_dca_order_1))
diff --git a/tests/test_integration.py b/tests/test_integration.py
index 9fb9fd8b3..2949f1ef2 100644
--- a/tests/test_integration.py
+++ b/tests/test_integration.py
@@ -75,8 +75,9 @@ def test_may_execute_exit_stoploss_on_exchange_multi(default_conf, ticker, fee,
         _notify_exit=MagicMock(),
     )
     mocker.patch("freqtrade.strategy.interface.IStrategy.should_exit", should_sell_mock)
-    wallets_mock = mocker.patch("freqtrade.wallets.Wallets.update", MagicMock())
-    mocker.patch("freqtrade.wallets.Wallets.get_free", MagicMock(return_value=1000))
+    wallets_mock = mocker.patch("freqtrade.wallets.Wallets.update")
+    mocker.patch("freqtrade.wallets.Wallets.get_free", return_value=1000)
+    mocker.patch("freqtrade.wallets.Wallets.check_exit_amount", return_value=True)
 
     freqtrade = get_patched_freqtradebot(mocker, default_conf)
     freqtrade.strategy.order_types['stoploss_on_exchange'] = True
diff --git a/tests/test_misc.py b/tests/test_misc.py
index 6b4343ab2..03a236d73 100644
--- a/tests/test_misc.py
+++ b/tests/test_misc.py
@@ -12,7 +12,7 @@ from freqtrade.misc import (dataframe_to_json, decimals_per_coin, deep_merge_dic
                             file_load_json, format_ms_time, json_to_dataframe, pair_to_filename,
                             parse_db_uri_for_logging, plural, render_template,
                             render_template_with_fallback, round_coin_value, safe_value_fallback,
-                            safe_value_fallback2, shorten_date)
+                            safe_value_fallback2)
 
 
 def test_decimals_per_coin():
@@ -39,12 +39,6 @@ def test_round_coin_value():
     assert round_coin_value(222.2, 'USDT', False, True) == '222.200'
 
 
-def test_shorten_date() -> None:
-    str_data = '1 day, 2 hours, 3 minutes, 4 seconds ago'
-    str_shorten_data = '1 d, 2 h, 3 min, 4 sec ago'
-    assert shorten_date(str_data) == str_shorten_data
-
-
 def test_file_dump_json(mocker) -> None:
     file_open = mocker.patch('freqtrade.misc.Path.open', MagicMock())
     json_dump = mocker.patch('rapidjson.dump', MagicMock())
diff --git a/tests/test_plotting.py b/tests/test_plotting.py
index 9f04ba20a..377caf59c 100644
--- a/tests/test_plotting.py
+++ b/tests/test_plotting.py
@@ -1,5 +1,4 @@
 from copy import deepcopy
-from pathlib import Path
 from unittest.mock import MagicMock
 
 import pandas as pd
@@ -282,13 +281,13 @@ def test_generate_Plot_filename():
     assert fn == "freqtrade-plot-UNITTEST_BTC-5m.html"
 
 
-def test_generate_plot_file(mocker, caplog):
+def test_generate_plot_file(mocker, caplog, user_dir):
     fig = generate_empty_figure()
     plot_mock = mocker.patch("freqtrade.plot.plotting.plot", MagicMock())
     store_plot_file(fig, filename="freqtrade-plot-UNITTEST_BTC-5m.html",
-                    directory=Path("user_data/plot"))
+                    directory=user_dir / "plot")
 
-    expected_fn = str(Path("user_data/plot/freqtrade-plot-UNITTEST_BTC-5m.html"))
+    expected_fn = str(user_dir / "plot/freqtrade-plot-UNITTEST_BTC-5m.html")
     assert plot_mock.call_count == 1
     assert plot_mock.call_args[0][0] == fig
     assert (plot_mock.call_args_list[0][1]['filename']
diff --git a/tests/test_strategy_updater.py b/tests/test_strategy_updater.py
index 597d49fda..3b48c952c 100644
--- a/tests/test_strategy_updater.py
+++ b/tests/test_strategy_updater.py
@@ -16,18 +16,18 @@ if sys.version_info < (3, 9):
     pytest.skip("StrategyUpdater is not compatible with Python 3.8", allow_module_level=True)
 
 
-def test_strategy_updater_start(tmpdir, capsys) -> None:
+def test_strategy_updater_start(user_dir, capsys) -> None:
     # Effective test without mocks.
     teststrats = Path(__file__).parent / 'strategy/strats'
-    tmpdirp = Path(tmpdir) / "strategies"
-    tmpdirp.mkdir()
+    tmpdirp = Path(user_dir) / "strategies"
+    tmpdirp.mkdir(parents=True, exist_ok=True)
     shutil.copy(teststrats / 'strategy_test_v2.py', tmpdirp)
     old_code = (teststrats / 'strategy_test_v2.py').read_text()
 
     args = [
         "strategy-updater",
         "--userdir",
-        str(tmpdir),
+        str(user_dir),
         "--strategy-list",
         "StrategyTestV2"
          ]
@@ -36,9 +36,9 @@ def test_strategy_updater_start(tmpdir, capsys) -> None:
 
     start_strategy_update(pargs)
 
-    assert Path(tmpdir / "strategies_orig_updater").exists()
+    assert Path(user_dir / "strategies_orig_updater").exists()
     # Backup file exists
-    assert Path(tmpdir / "strategies_orig_updater" / 'strategy_test_v2.py').exists()
+    assert Path(user_dir / "strategies_orig_updater" / 'strategy_test_v2.py').exists()
     # updated file exists
     new_file = Path(tmpdirp / 'strategy_test_v2.py')
     assert new_file.exists()
diff --git a/tests/test_timerange.py b/tests/test_timerange.py
index 993b24d95..d1c61704f 100644
--- a/tests/test_timerange.py
+++ b/tests/test_timerange.py
@@ -1,7 +1,6 @@
 # pragma pylint: disable=missing-docstring, C0103
 from datetime import datetime, timezone
 
-import arrow
 import pytest
 
 from freqtrade.configuration import TimeRange
@@ -69,7 +68,7 @@ def test_subtract_start():
 
 
 def test_adjust_start_if_necessary():
-    min_date = arrow.Arrow(2017, 11, 14, 21, 15, 00)
+    min_date = datetime(2017, 11, 14, 21, 15, 00, tzinfo=timezone.utc)
 
     x = TimeRange('date', 'date', 1510694100, 1510780500)
     # Adjust by 20 candles - min_date == startts
diff --git a/tests/test_wallets.py b/tests/test_wallets.py
index 7ccc8d0f5..c3ff4ccd0 100644
--- a/tests/test_wallets.py
+++ b/tests/test_wallets.py
@@ -3,9 +3,11 @@ from copy import deepcopy
 from unittest.mock import MagicMock
 
 import pytest
+from sqlalchemy import select
 
 from freqtrade.constants import UNLIMITED_STAKE_AMOUNT
 from freqtrade.exceptions import DependencyException
+from freqtrade.persistence import Trade
 from tests.conftest import EXMS, create_mock_trades, get_patched_freqtradebot, patch_wallet
 
 
@@ -43,7 +45,7 @@ def test_sync_wallet_at_boot(mocker, default_conf):
     assert freqtrade.wallets._wallets['GAS'].total == 0.260739
     assert freqtrade.wallets.get_free('BNT') == 1.0
     assert 'USDT' in freqtrade.wallets._wallets
-    assert freqtrade.wallets._last_wallet_refresh > 0
+    assert freqtrade.wallets._last_wallet_refresh is not None
     mocker.patch.multiple(
         EXMS,
         get_balances=MagicMock(return_value={
@@ -330,7 +332,7 @@ def test_sync_wallet_futures_live(mocker, default_conf):
 
     assert 'USDT' in freqtrade.wallets._wallets
     assert 'ETH/USDT:USDT' in freqtrade.wallets._positions
-    assert freqtrade.wallets._last_wallet_refresh > 0
+    assert freqtrade.wallets._last_wallet_refresh is not None
 
     # Remove ETH/USDT:USDT position
     del mock_result[0]
@@ -364,3 +366,48 @@ def test_sync_wallet_futures_dry(mocker, default_conf, fee):
     free = freqtrade.wallets.get_free('BTC')
     used = freqtrade.wallets.get_used('BTC')
     assert free + used == total
+
+
+def test_check_exit_amount(mocker, default_conf, fee):
+    freqtrade = get_patched_freqtradebot(mocker, default_conf)
+    update_mock = mocker.patch("freqtrade.wallets.Wallets.update")
+    total_mock = mocker.patch("freqtrade.wallets.Wallets.get_total", return_value=123)
+
+    create_mock_trades(fee, is_short=None)
+    trade = Trade.session.scalars(select(Trade)).first()
+    assert trade.amount == 123
+
+    assert freqtrade.wallets.check_exit_amount(trade) is True
+    assert update_mock.call_count == 0
+    assert total_mock.call_count == 1
+
+    update_mock.reset_mock()
+    # Reduce returned amount to below the trade amount - which should
+    # trigger a wallet update and return False, triggering "order refinding"
+    total_mock = mocker.patch("freqtrade.wallets.Wallets.get_total", return_value=100)
+    assert freqtrade.wallets.check_exit_amount(trade) is False
+    assert update_mock.call_count == 1
+    assert total_mock.call_count == 2
+
+
+def test_check_exit_amount_futures(mocker, default_conf, fee):
+    default_conf['trading_mode'] = 'futures'
+    default_conf['margin_mode'] = 'isolated'
+    freqtrade = get_patched_freqtradebot(mocker, default_conf)
+    total_mock = mocker.patch("freqtrade.wallets.Wallets.get_total", return_value=123)
+
+    create_mock_trades(fee, is_short=None)
+    trade = Trade.session.scalars(select(Trade)).first()
+    trade.trading_mode = 'futures'
+    assert trade.amount == 123
+
+    assert freqtrade.wallets.check_exit_amount(trade) is True
+    assert total_mock.call_count == 0
+
+    update_mock = mocker.patch("freqtrade.wallets.Wallets.update")
+    trade.amount = 150
+    # Reduce returned amount to below the trade amount - which should
+    # trigger a wallet update and return False, triggering "order refinding"
+    assert freqtrade.wallets.check_exit_amount(trade) is False
+    assert total_mock.call_count == 0
+    assert update_mock.call_count == 1
diff --git a/tests/exchange/test_ccxt_precise.py b/tests/utils/test_ccxt_precise.py
similarity index 100%
rename from tests/exchange/test_ccxt_precise.py
rename to tests/utils/test_ccxt_precise.py
diff --git a/tests/utils/test_datetime_helpers.py b/tests/utils/test_datetime_helpers.py
new file mode 100644
index 000000000..5aec0da54
--- /dev/null
+++ b/tests/utils/test_datetime_helpers.py
@@ -0,0 +1,59 @@
+from datetime import datetime, timedelta, timezone
+
+import pytest
+import time_machine
+
+from freqtrade.util import dt_floor_day, dt_from_ts, dt_now, dt_ts, dt_utc, shorten_date
+from freqtrade.util.datetime_helpers import dt_humanize
+
+
+def test_dt_now():
+    with time_machine.travel("2021-09-01 05:01:00 +00:00", tick=False) as t:
+        now = datetime.now(timezone.utc)
+        assert dt_now() == now
+        assert dt_ts() == int(now.timestamp() * 1000)
+        assert dt_ts(now) == int(now.timestamp() * 1000)
+
+        t.shift(timedelta(hours=5))
+        assert dt_now() >= now
+        assert dt_now() == datetime.now(timezone.utc)
+        assert dt_ts() == int(dt_now().timestamp() * 1000)
+        # Test with different time than now
+        assert dt_ts(now) == int(now.timestamp() * 1000)
+
+
+def test_dt_utc():
+    assert dt_utc(2023, 5, 5) == datetime(2023, 5, 5, tzinfo=timezone.utc)
+    assert dt_utc(2023, 5, 5, 0, 0, 0, 555500) == datetime(2023, 5, 5, 0, 0, 0, 555500,
+                                                           tzinfo=timezone.utc)
+
+
+@pytest.mark.parametrize('as_ms', [True, False])
+def test_dt_from_ts(as_ms):
+    multi = 1000 if as_ms else 1
+    assert dt_from_ts(1683244800.0 * multi) == datetime(2023, 5, 5, tzinfo=timezone.utc)
+    assert dt_from_ts(1683244800.5555 * multi) == datetime(2023, 5, 5, 0, 0, 0, 555500,
+                                                           tzinfo=timezone.utc)
+    # As int
+    assert dt_from_ts(1683244800 * multi) == datetime(2023, 5, 5, tzinfo=timezone.utc)
+    # As milliseconds
+    assert dt_from_ts(1683244800 * multi) == datetime(2023, 5, 5, tzinfo=timezone.utc)
+    assert dt_from_ts(1683242400 * multi) == datetime(2023, 5, 4, 23, 20, tzinfo=timezone.utc)
+
+
+def test_dt_floor_day():
+    now = datetime(2023, 9, 1, 5, 2, 3, 455555, tzinfo=timezone.utc)
+
+    assert dt_floor_day(now) == datetime(2023, 9, 1, tzinfo=timezone.utc)
+
+
+def test_shorten_date() -> None:
+    str_data = '1 day, 2 hours, 3 minutes, 4 seconds ago'
+    str_shorten_data = '1 d, 2 h, 3 min, 4 sec ago'
+    assert shorten_date(str_data) == str_shorten_data
+
+
+def test_dt_humanize() -> None:
+    assert dt_humanize(dt_now()) == 'just now'
+    assert dt_humanize(dt_now(), only_distance=True) == 'instantly'
+    assert dt_humanize(dt_now() - timedelta(hours=16), only_distance=True) == '16 hours'
diff --git a/tests/test_periodiccache.py b/tests/utils/test_periodiccache.py
similarity index 100%
rename from tests/test_periodiccache.py
rename to tests/utils/test_periodiccache.py