diff --git a/freqtrade/main.py b/freqtrade/main.py
index 58fbdde24..28244dd1c 100755
--- a/freqtrade/main.py
+++ b/freqtrade/main.py
@@ -12,15 +12,11 @@ from typing import Dict, Optional, List
 import requests
 from cachetools import cached, TTLCache
 
-from freqtrade import __version__, exchange, persistence
+from freqtrade import __version__, exchange, persistence, rpc
 from freqtrade.analyze import get_signal, SignalType
-from freqtrade.misc import (
-    FreqtradeException
-)
 from freqtrade.misc import State, get_state, update_state, parse_args, throttle, \
-    load_config
+    load_config, FreqtradeException
 from freqtrade.persistence import Trade
-from freqtrade.rpc import telegram
 
 logger = logging.getLogger('freqtrade')
 
@@ -102,7 +98,7 @@ def _process(dynamic_whitelist: Optional[bool] = False) -> bool:
         )
         time.sleep(30)
     except RuntimeError:
-        telegram.send_msg('*Status:* Got RuntimeError:\n```\n{traceback}```{hint}'.format(
+        rpc.send_msg('*Status:* Got RuntimeError:\n```\n{traceback}```{hint}'.format(
             traceback=traceback.format_exc(),
             hint='Issue `/start` if you think it is safe to restart.'
         ))
@@ -131,7 +127,7 @@ def execute_sell(trade: Trade, limit: float) -> None:
         fmt_exp_profit
     )
     logger.info(message)
-    telegram.send_msg(message)
+    rpc.send_msg(message)
 
 
 def min_roi_reached(trade: Trade, current_rate: float, current_time: datetime) -> bool:
@@ -225,7 +221,7 @@ def create_trade(stake_amount: float) -> Optional[Trade]:
         buy_limit
     )
     logger.info(message)
-    telegram.send_msg(message)
+    rpc.send_msg(message)
     # Fee is applied twice because we make a LIMIT_BUY and LIMIT_SELL
     return Trade(pair=pair,
                  stake_amount=stake_amount,
@@ -245,7 +241,7 @@ def init(config: dict, db_url: Optional[str] = None) -> None:
     :return: None
     """
     # Initialize all modules
-    telegram.init(config)
+    rpc.init(config)
     persistence.init(config, db_url)
     exchange.init(config)
 
@@ -283,11 +279,11 @@ def cleanup(*args, **kwargs) -> None:
     Cleanup the application state und finish all pending tasks
     :return: None
     """
-    telegram.send_msg('*Status:* `Stopping trader...`')
+    rpc.send_msg('*Status:* `Stopping trader...`')
     logger.info('Stopping trader and cleaning up modules...')
     update_state(State.STOPPED)
     persistence.cleanup()
-    telegram.cleanup()
+    rpc.cleanup()
     exit(0)
 
 
@@ -325,7 +321,7 @@ def main():
         new_state = get_state()
         # Log state transition
         if new_state != old_state:
-            telegram.send_msg('*Status:* `{}`'.format(new_state.name.lower()))
+            rpc.send_msg('*Status:* `{}`'.format(new_state.name.lower()))
             logger.info('Changing state to: %s', new_state.name)
 
         if new_state == State.STOPPED:
diff --git a/freqtrade/rpc/__init__.py b/freqtrade/rpc/__init__.py
index 35fa001c3..363c314fb 100644
--- a/freqtrade/rpc/__init__.py
+++ b/freqtrade/rpc/__init__.py
@@ -1 +1,34 @@
 from . import telegram
+
+REGISTERED_MODULES = []
+
+
+def init(config: dict) -> None:
+    """
+    Initializes all enabled rpc modules
+    :param config: config to use
+    :return: None
+    """
+
+    if config['telegram'].get('enabled', False):
+        REGISTERED_MODULES.append('telegram')
+        telegram.init(config)
+
+
+def cleanup() -> None:
+    """
+    Stops all enabled rpc modules
+    :return: None
+    """
+    if 'telegram' in REGISTERED_MODULES:
+        telegram.cleanup()
+
+
+def send_msg(msg: str) -> None:
+    """
+    Send given markdown message to all registered rpc modules
+    :param msg: message
+    :return: None
+    """
+    if 'telegram' in REGISTERED_MODULES:
+        telegram.send_msg(msg)
diff --git a/freqtrade/tests/test_main.py b/freqtrade/tests/test_main.py
index 4fe87ce6e..3de35ff46 100644
--- a/freqtrade/tests/test_main.py
+++ b/freqtrade/tests/test_main.py
@@ -16,7 +16,7 @@ from freqtrade.persistence import Trade
 
 def test_process_trade_creation(default_conf, ticker, health, mocker):
     mocker.patch.dict('freqtrade.main._CONF', default_conf)
-    mocker.patch.multiple('freqtrade.main.telegram', init=MagicMock(), send_msg=MagicMock())
+    mocker.patch.multiple('freqtrade.rpc', init=MagicMock(), send_msg=MagicMock())
     mocker.patch('freqtrade.main.get_signal', side_effect=lambda s, t: True)
     mocker.patch.multiple('freqtrade.main.exchange',
                           validate_pairs=MagicMock(),
@@ -45,7 +45,7 @@ def test_process_trade_creation(default_conf, ticker, health, mocker):
 
 def test_process_exchange_failures(default_conf, ticker, health, mocker):
     mocker.patch.dict('freqtrade.main._CONF', default_conf)
-    mocker.patch.multiple('freqtrade.main.telegram', init=MagicMock(), send_msg=MagicMock())
+    mocker.patch.multiple('freqtrade.rpc', init=MagicMock(), send_msg=MagicMock())
     mocker.patch('freqtrade.main.get_signal', side_effect=lambda s, t: True)
     sleep_mock = mocker.patch('time.sleep', side_effect=lambda _: None)
     mocker.patch.multiple('freqtrade.main.exchange',
@@ -62,7 +62,7 @@ def test_process_exchange_failures(default_conf, ticker, health, mocker):
 def test_process_runtime_error(default_conf, ticker, health, mocker):
     msg_mock = MagicMock()
     mocker.patch.dict('freqtrade.main._CONF', default_conf)
-    mocker.patch.multiple('freqtrade.main.telegram', init=MagicMock(), send_msg=msg_mock)
+    mocker.patch.multiple('freqtrade.rpc', init=MagicMock(), send_msg=msg_mock)
     mocker.patch('freqtrade.main.get_signal', side_effect=lambda s, t: True)
     mocker.patch.multiple('freqtrade.main.exchange',
                           validate_pairs=MagicMock(),
@@ -80,7 +80,7 @@ def test_process_runtime_error(default_conf, ticker, health, mocker):
 
 def test_process_trade_handling(default_conf, ticker, limit_buy_order, health, mocker):
     mocker.patch.dict('freqtrade.main._CONF', default_conf)
-    mocker.patch.multiple('freqtrade.main.telegram', init=MagicMock(), send_msg=MagicMock())
+    mocker.patch.multiple('freqtrade.rpc', init=MagicMock(), send_msg=MagicMock())
     mocker.patch('freqtrade.main.get_signal',
                  side_effect=lambda *args: False if args[1] == SignalType.SELL else True)
     mocker.patch.multiple('freqtrade.main.exchange',
@@ -105,7 +105,7 @@ def test_process_trade_handling(default_conf, ticker, limit_buy_order, health, m
 def test_create_trade(default_conf, ticker, limit_buy_order, mocker):
     mocker.patch.dict('freqtrade.main._CONF', default_conf)
     mocker.patch('freqtrade.main.get_signal', side_effect=lambda s, t: True)
-    mocker.patch.multiple('freqtrade.main.telegram', init=MagicMock(), send_msg=MagicMock())
+    mocker.patch.multiple('freqtrade.rpc', init=MagicMock(), send_msg=MagicMock())
     mocker.patch.multiple('freqtrade.main.exchange',
                           validate_pairs=MagicMock(),
                           get_ticker=ticker,
@@ -135,7 +135,7 @@ def test_create_trade(default_conf, ticker, limit_buy_order, mocker):
 def test_create_trade_no_stake_amount(default_conf, ticker, mocker):
     mocker.patch.dict('freqtrade.main._CONF', default_conf)
     mocker.patch('freqtrade.main.get_signal', side_effect=lambda s, t: True)
-    mocker.patch.multiple('freqtrade.main.telegram', init=MagicMock(), send_msg=MagicMock())
+    mocker.patch.multiple('freqtrade.rpc', init=MagicMock(), send_msg=MagicMock())
     mocker.patch.multiple('freqtrade.main.exchange',
                           validate_pairs=MagicMock(),
                           get_ticker=ticker,
@@ -148,7 +148,7 @@ def test_create_trade_no_stake_amount(default_conf, ticker, mocker):
 def test_create_trade_no_pairs(default_conf, ticker, mocker):
     mocker.patch.dict('freqtrade.main._CONF', default_conf)
     mocker.patch('freqtrade.main.get_signal', side_effect=lambda s, t: True)
-    mocker.patch.multiple('freqtrade.main.telegram', init=MagicMock(), send_msg=MagicMock())
+    mocker.patch.multiple('freqtrade.rpc', init=MagicMock(), send_msg=MagicMock())
     mocker.patch.multiple('freqtrade.main.exchange',
                           validate_pairs=MagicMock(),
                           get_ticker=ticker,
@@ -164,7 +164,7 @@ def test_create_trade_no_pairs(default_conf, ticker, mocker):
 def test_handle_trade(default_conf, limit_buy_order, limit_sell_order, mocker):
     mocker.patch.dict('freqtrade.main._CONF', default_conf)
     mocker.patch('freqtrade.main.get_signal', side_effect=lambda s, t: True)
-    mocker.patch.multiple('freqtrade.main.telegram', init=MagicMock(), send_msg=MagicMock())
+    mocker.patch.multiple('freqtrade.rpc', init=MagicMock(), send_msg=MagicMock())
     mocker.patch.multiple('freqtrade.main.exchange',
                           validate_pairs=MagicMock(),
                           get_ticker=MagicMock(return_value={
@@ -196,7 +196,7 @@ def test_handle_trade(default_conf, limit_buy_order, limit_sell_order, mocker):
 def test_close_trade(default_conf, ticker, limit_buy_order, limit_sell_order, mocker):
     mocker.patch.dict('freqtrade.main._CONF', default_conf)
     mocker.patch('freqtrade.main.get_signal', side_effect=lambda s, t: True)
-    mocker.patch.multiple('freqtrade.main.telegram', init=MagicMock(), send_msg=MagicMock())
+    mocker.patch.multiple('freqtrade.rpc', init=MagicMock(), send_msg=MagicMock())
     mocker.patch.multiple('freqtrade.main.exchange',
                           validate_pairs=MagicMock(),
                           get_ticker=ticker,
diff --git a/freqtrade/tests/test_rpc.py b/freqtrade/tests/test_rpc.py
new file mode 100644
index 000000000..2dcb1d300
--- /dev/null
+++ b/freqtrade/tests/test_rpc.py
@@ -0,0 +1,58 @@
+# pragma pylint: disable=missing-docstring, too-many-arguments, too-many-ancestors, C0103
+from unittest.mock import MagicMock
+
+from copy import deepcopy
+
+from freqtrade.rpc import init, cleanup, send_msg
+
+
+def test_init_telegram_enabled(default_conf, mocker):
+    module_list = []
+    mocker.patch('freqtrade.rpc.REGISTERED_MODULES', module_list)
+    telegram_mock = mocker.patch('freqtrade.rpc.telegram.init', MagicMock())
+
+    init(default_conf)
+
+    assert telegram_mock.call_count == 1
+    assert 'telegram' in module_list
+
+
+def test_init_telegram_disabled(default_conf, mocker):
+    module_list = []
+    mocker.patch('freqtrade.rpc.REGISTERED_MODULES', module_list)
+    telegram_mock = mocker.patch('freqtrade.rpc.telegram.init', MagicMock())
+
+    conf = deepcopy(default_conf)
+    conf['telegram']['enabled'] = False
+    init(conf)
+
+    assert telegram_mock.call_count == 0
+    assert 'telegram' not in module_list
+
+
+def test_cleanup_telegram_enabled(mocker):
+    mocker.patch('freqtrade.rpc.REGISTERED_MODULES', ['telegram'])
+    telegram_mock = mocker.patch('freqtrade.rpc.telegram.cleanup', MagicMock())
+    cleanup()
+    assert telegram_mock.call_count == 1
+
+
+def test_cleanup_telegram_disabled(mocker):
+    mocker.patch('freqtrade.rpc.REGISTERED_MODULES', [])
+    telegram_mock = mocker.patch('freqtrade.rpc.telegram.cleanup', MagicMock())
+    cleanup()
+    assert telegram_mock.call_count == 0
+
+
+def test_send_msg_telegram_enabled(mocker):
+    mocker.patch('freqtrade.rpc.REGISTERED_MODULES', ['telegram'])
+    telegram_mock = mocker.patch('freqtrade.rpc.telegram.send_msg', MagicMock())
+    send_msg('test')
+    assert telegram_mock.call_count == 1
+
+
+def test_send_msg_telegram_disabled(mocker):
+    mocker.patch('freqtrade.rpc.REGISTERED_MODULES', [])
+    telegram_mock = mocker.patch('freqtrade.rpc.telegram.send_msg', MagicMock())
+    send_msg('test')
+    assert telegram_mock.call_count == 0
diff --git a/freqtrade/tests/test_telegram.py b/freqtrade/tests/test_rpc_telegram.py
similarity index 89%
rename from freqtrade/tests/test_telegram.py
rename to freqtrade/tests/test_rpc_telegram.py
index f786a9702..ebedc5962 100644
--- a/freqtrade/tests/test_telegram.py
+++ b/freqtrade/tests/test_rpc_telegram.py
@@ -13,10 +13,8 @@ from freqtrade.main import init, create_trade
 from freqtrade.misc import update_state, State, get_state
 from freqtrade.persistence import Trade
 from freqtrade.rpc import telegram
-from freqtrade.rpc.telegram import (
-    _status, _status_table, _profit, _forcesell, _performance, _count, _start, _stop, _balance,
-    authorized_only, _help, is_enabled, send_msg,
-    _version)
+from freqtrade.rpc.telegram import authorized_only, is_enabled, send_msg, _status, _status_table, \
+    _profit, _forcesell, _performance, _count, _start, _stop, _balance, _version, _help
 
 
 def test_is_enabled(default_conf, mocker):
@@ -80,7 +78,8 @@ def test_status_handle(default_conf, update, ticker, mocker):
     mocker.patch.dict('freqtrade.main._CONF', default_conf)
     mocker.patch('freqtrade.main.get_signal', side_effect=lambda s, t: True)
     msg_mock = MagicMock()
-    mocker.patch.multiple('freqtrade.main.telegram',
+    mocker.patch('freqtrade.main.rpc.send_msg', MagicMock())
+    mocker.patch.multiple('freqtrade.rpc.telegram',
                           _CONF=default_conf,
                           init=MagicMock(),
                           send_msg=msg_mock)
@@ -110,16 +109,17 @@ def test_status_handle(default_conf, update, ticker, mocker):
     # Trigger status while we have a fulfilled order for the open trade
     _status(bot=MagicMock(), update=update)
 
-    assert msg_mock.call_count == 2
-    assert '[BTC_ETH]' in msg_mock.call_args_list[-1][0][0]
+    assert msg_mock.call_count == 1
+    assert '[BTC_ETH]' in msg_mock.call_args_list[0][0][0]
 
 
 def test_status_table_handle(default_conf, update, ticker, mocker):
     mocker.patch.dict('freqtrade.main._CONF', default_conf)
     mocker.patch('freqtrade.main.get_signal', side_effect=lambda s, t: True)
     msg_mock = MagicMock()
+    mocker.patch('freqtrade.main.rpc.send_msg', MagicMock())
     mocker.patch.multiple(
-        'freqtrade.main.telegram',
+        'freqtrade.rpc.telegram',
         _CONF=default_conf,
         init=MagicMock(),
         send_msg=msg_mock)
@@ -154,14 +154,15 @@ def test_status_table_handle(default_conf, update, ticker, mocker):
 
     assert int(fields[0]) == 1
     assert fields[1] == 'BTC_ETH'
-    assert msg_mock.call_count == 2
+    assert msg_mock.call_count == 1
 
 
 def test_profit_handle(default_conf, update, ticker, limit_buy_order, limit_sell_order, mocker):
     mocker.patch.dict('freqtrade.main._CONF', default_conf)
     mocker.patch('freqtrade.main.get_signal', side_effect=lambda s, t: True)
     msg_mock = MagicMock()
-    mocker.patch.multiple('freqtrade.main.telegram',
+    mocker.patch('freqtrade.main.rpc.send_msg', MagicMock())
+    mocker.patch.multiple('freqtrade.rpc.telegram',
                           _CONF=default_conf,
                           init=MagicMock(),
                           send_msg=msg_mock)
@@ -183,7 +184,7 @@ def test_profit_handle(default_conf, update, ticker, limit_buy_order, limit_sell
     trade.update(limit_buy_order)
 
     _profit(bot=MagicMock(), update=update)
-    assert msg_mock.call_count == 2
+    assert msg_mock.call_count == 1
     assert 'no closed trade' in msg_mock.call_args_list[-1][0][0]
     msg_mock.reset_mock()
 
@@ -204,11 +205,11 @@ def test_profit_handle(default_conf, update, ticker, limit_buy_order, limit_sell
 def test_forcesell_handle(default_conf, update, ticker, mocker):
     mocker.patch.dict('freqtrade.main._CONF', default_conf)
     mocker.patch('freqtrade.main.get_signal', side_effect=lambda s, t: True)
-    msg_mock = MagicMock()
-    mocker.patch.multiple('freqtrade.main.telegram',
+    rpc_mock = mocker.patch('freqtrade.main.rpc.send_msg', MagicMock())
+    mocker.patch.multiple('freqtrade.rpc.telegram',
                           _CONF=default_conf,
                           init=MagicMock(),
-                          send_msg=msg_mock)
+                          send_msg=MagicMock())
     mocker.patch.multiple('freqtrade.main.exchange',
                           validate_pairs=MagicMock(),
                           get_ticker=ticker)
@@ -224,19 +225,19 @@ def test_forcesell_handle(default_conf, update, ticker, mocker):
     update.message.text = '/forcesell 1'
     _forcesell(bot=MagicMock(), update=update)
 
-    assert msg_mock.call_count == 2
-    assert 'Selling [BTC/ETH]' in msg_mock.call_args_list[-1][0][0]
-    assert '0.07256061 (profit: ~-0.64%)' in msg_mock.call_args_list[-1][0][0]
+    assert rpc_mock.call_count == 2
+    assert 'Selling [BTC/ETH]' in rpc_mock.call_args_list[-1][0][0]
+    assert '0.07256061 (profit: ~-0.64%)' in rpc_mock.call_args_list[-1][0][0]
 
 
 def test_forcesell_all_handle(default_conf, update, ticker, mocker):
     mocker.patch.dict('freqtrade.main._CONF', default_conf)
     mocker.patch('freqtrade.main.get_signal', side_effect=lambda s, t: True)
-    msg_mock = MagicMock()
-    mocker.patch.multiple('freqtrade.main.telegram',
+    rpc_mock = mocker.patch('freqtrade.main.rpc.send_msg', MagicMock())
+    mocker.patch.multiple('freqtrade.rpc.telegram',
                           _CONF=default_conf,
                           init=MagicMock(),
-                          send_msg=msg_mock)
+                          send_msg=MagicMock())
     mocker.patch.multiple('freqtrade.main.exchange',
                           validate_pairs=MagicMock(),
                           get_ticker=ticker)
@@ -246,14 +247,13 @@ def test_forcesell_all_handle(default_conf, update, ticker, mocker):
     for _ in range(4):
         Trade.session.add(create_trade(15.0))
     Trade.session.flush()
-
-    msg_mock.reset_mock()
+    rpc_mock.reset_mock()
 
     update.message.text = '/forcesell all'
     _forcesell(bot=MagicMock(), update=update)
 
-    assert msg_mock.call_count == 4
-    for args in msg_mock.call_args_list:
+    assert rpc_mock.call_count == 4
+    for args in rpc_mock.call_args_list:
         assert '0.07256061 (profit: ~-0.64%)' in args[0][0]
 
 
@@ -261,7 +261,7 @@ def test_forcesell_handle_invalid(default_conf, update, mocker):
     mocker.patch.dict('freqtrade.main._CONF', default_conf)
     mocker.patch('freqtrade.main.get_signal', side_effect=lambda s, t: True)
     msg_mock = MagicMock()
-    mocker.patch.multiple('freqtrade.main.telegram',
+    mocker.patch.multiple('freqtrade.rpc.telegram',
                           _CONF=default_conf,
                           init=MagicMock(),
                           send_msg=msg_mock)
@@ -298,7 +298,8 @@ def test_performance_handle(
     mocker.patch.dict('freqtrade.main._CONF', default_conf)
     mocker.patch('freqtrade.main.get_signal', side_effect=lambda s, t: True)
     msg_mock = MagicMock()
-    mocker.patch.multiple('freqtrade.main.telegram',
+    mocker.patch('freqtrade.main.rpc.send_msg', MagicMock())
+    mocker.patch.multiple('freqtrade.rpc.telegram',
                           _CONF=default_conf,
                           init=MagicMock(),
                           send_msg=msg_mock)
@@ -323,9 +324,9 @@ def test_performance_handle(
     Trade.session.flush()
 
     _performance(bot=MagicMock(), update=update)
-    assert msg_mock.call_count == 2
-    assert 'Performance' in msg_mock.call_args_list[-1][0][0]
-    assert '<code>BTC_ETH\t10.05%</code>' in msg_mock.call_args_list[-1][0][0]
+    assert msg_mock.call_count == 1
+    assert 'Performance' in msg_mock.call_args_list[0][0][0]
+    assert '<code>BTC_ETH\t10.05%</code>' in msg_mock.call_args_list[0][0][0]
 
 
 def test_count_handle(default_conf, update, ticker, mocker):
@@ -333,7 +334,7 @@ def test_count_handle(default_conf, update, ticker, mocker):
     mocker.patch('freqtrade.main.get_signal', side_effect=lambda s, t: True)
     msg_mock = MagicMock()
     mocker.patch.multiple(
-        'freqtrade.main.telegram',
+        'freqtrade.rpc.telegram',
         _CONF=default_conf,
         init=MagicMock(),
         send_msg=msg_mock)
@@ -366,7 +367,7 @@ def test_performance_handle_invalid(default_conf, update, mocker):
     mocker.patch.dict('freqtrade.main._CONF', default_conf)
     mocker.patch('freqtrade.main.get_signal', side_effect=lambda s, t: True)
     msg_mock = MagicMock()
-    mocker.patch.multiple('freqtrade.main.telegram',
+    mocker.patch.multiple('freqtrade.rpc.telegram',
                           _CONF=default_conf,
                           init=MagicMock(),
                           send_msg=msg_mock)
@@ -384,7 +385,7 @@ def test_performance_handle_invalid(default_conf, update, mocker):
 def test_start_handle(default_conf, update, mocker):
     mocker.patch.dict('freqtrade.main._CONF', default_conf)
     msg_mock = MagicMock()
-    mocker.patch.multiple('freqtrade.main.telegram',
+    mocker.patch.multiple('freqtrade.rpc.telegram',
                           _CONF=default_conf,
                           init=MagicMock(),
                           send_msg=msg_mock)
@@ -402,7 +403,7 @@ def test_start_handle(default_conf, update, mocker):
 def test_start_handle_already_running(default_conf, update, mocker):
     mocker.patch.dict('freqtrade.main._CONF', default_conf)
     msg_mock = MagicMock()
-    mocker.patch.multiple('freqtrade.main.telegram',
+    mocker.patch.multiple('freqtrade.rpc.telegram',
                           _CONF=default_conf,
                           init=MagicMock(),
                           send_msg=msg_mock)
@@ -421,7 +422,7 @@ def test_start_handle_already_running(default_conf, update, mocker):
 def test_stop_handle(default_conf, update, mocker):
     mocker.patch.dict('freqtrade.main._CONF', default_conf)
     msg_mock = MagicMock()
-    mocker.patch.multiple('freqtrade.main.telegram',
+    mocker.patch.multiple('freqtrade.rpc.telegram',
                           _CONF=default_conf,
                           init=MagicMock(),
                           send_msg=msg_mock)
@@ -440,7 +441,7 @@ def test_stop_handle(default_conf, update, mocker):
 def test_stop_handle_already_stopped(default_conf, update, mocker):
     mocker.patch.dict('freqtrade.main._CONF', default_conf)
     msg_mock = MagicMock()
-    mocker.patch.multiple('freqtrade.main.telegram',
+    mocker.patch.multiple('freqtrade.rpc.telegram',
                           _CONF=default_conf,
                           init=MagicMock(),
                           send_msg=msg_mock)
@@ -472,7 +473,7 @@ def test_balance_handle(default_conf, update, mocker):
     }]
     mocker.patch.dict('freqtrade.main._CONF', default_conf)
     msg_mock = MagicMock()
-    mocker.patch.multiple('freqtrade.main.telegram',
+    mocker.patch.multiple('freqtrade.rpc.telegram',
                           _CONF=default_conf,
                           init=MagicMock(),
                           send_msg=msg_mock)
@@ -488,7 +489,7 @@ def test_balance_handle(default_conf, update, mocker):
 def test_help_handle(default_conf, update, mocker):
     mocker.patch.dict('freqtrade.main._CONF', default_conf)
     msg_mock = MagicMock()
-    mocker.patch.multiple('freqtrade.main.telegram',
+    mocker.patch.multiple('freqtrade.rpc.telegram',
                           _CONF=default_conf,
                           init=MagicMock(),
                           send_msg=msg_mock)
@@ -501,7 +502,7 @@ def test_help_handle(default_conf, update, mocker):
 def test_version_handle(default_conf, update, mocker):
     mocker.patch.dict('freqtrade.main._CONF', default_conf)
     msg_mock = MagicMock()
-    mocker.patch.multiple('freqtrade.main.telegram',
+    mocker.patch.multiple('freqtrade.rpc.telegram',
                           _CONF=default_conf,
                           init=MagicMock(),
                           send_msg=msg_mock)
@@ -513,7 +514,7 @@ def test_version_handle(default_conf, update, mocker):
 
 def test_send_msg(default_conf, mocker):
     mocker.patch.dict('freqtrade.main._CONF', default_conf)
-    mocker.patch.multiple('freqtrade.main.telegram',
+    mocker.patch.multiple('freqtrade.rpc.telegram',
                           _CONF=default_conf,
                           init=MagicMock())
     bot = MagicMock()
@@ -528,7 +529,7 @@ def test_send_msg(default_conf, mocker):
 
 def test_send_msg_network_error(default_conf, mocker):
     mocker.patch.dict('freqtrade.main._CONF', default_conf)
-    mocker.patch.multiple('freqtrade.main.telegram',
+    mocker.patch.multiple('freqtrade.rpc.telegram',
                           _CONF=default_conf,
                           init=MagicMock())
     default_conf['telegram']['enabled'] = True