diff --git a/contrib/akamai/controlbar/ControlBar.js b/contrib/akamai/controlbar/ControlBar.js
index 4b5d13af6a..49cb791555 100644
--- a/contrib/akamai/controlbar/ControlBar.js
+++ b/contrib/akamai/controlbar/ControlBar.js
@@ -53,6 +53,7 @@ var ControlBar = function (dashjsMediaPlayer, displayUTCTimeCodes) {
     var videoControllerVisibleTimeout = 0;
     var liveThresholdSecs = 12;
     var textTrackList = {};
+    var forceQuality = false;
     var video,
         videoContainer,
         videoController,
@@ -845,7 +846,7 @@ var ControlBar = function (dashjsMediaPlayer, displayUTCTimeCodes) {
                             if (item.index > 0) {
                                 cfg.streaming.abr.autoSwitchBitrate[item.mediaType] = false;
                                 self.player.updateSettings(cfg);
-                                self.player.setQualityFor(item.mediaType, item.index - 1);
+                                self.player.setQualityFor(item.mediaType, item.index - 1, forceQuality);
                             } else {
                                 cfg.streaming.abr.autoSwitchBitrate[item.mediaType] = true;
                                 self.player.updateSettings(cfg);
@@ -1015,6 +1016,10 @@ var ControlBar = function (dashjsMediaPlayer, displayUTCTimeCodes) {
             videoController.classList.remove('disable');
         },
 
+        forceQualitySwitch: function (value) {
+            forceQuality = value;
+        },
+
         resetSelectionMenus: function () {
             if (menuHandlersList.bitrate) {
                 bitrateListBtn.removeEventListener('click', menuHandlersList.bitrate);
diff --git a/index.d.ts b/index.d.ts
index 240fcffa6c..4556be4683 100644
--- a/index.d.ts
+++ b/index.d.ts
@@ -464,7 +464,7 @@ declare namespace dashjs {
 
         getQualityFor(type: MediaType): number;
 
-        setQualityFor(type: MediaType, value: number): void;
+        setQualityFor(type: MediaType, value: number, replace?: boolean): void;
 
         updatePortalSize(): void;
 
diff --git a/samples/dash-if-reference-player/app/main.js b/samples/dash-if-reference-player/app/main.js
index 95ca5f09fc..0133b756ea 100644
--- a/samples/dash-if-reference-player/app/main.js
+++ b/samples/dash-if-reference-player/app/main.js
@@ -227,6 +227,7 @@ app.controller('DashController', ['$scope', '$window', 'sources', 'contributors'
     $scope.jumpGapsSelected = true;
     $scope.fastSwitchSelected = true;
     $scope.videoAutoSwitchSelected = true;
+    $scope.forceQualitySwitchSelected = false;
     $scope.videoQualities = [];
     $scope.ABRStrategy = 'abrDynamic';
 
@@ -537,6 +538,10 @@ app.controller('DashController', ['$scope', '$window', 'sources', 'contributors'
         });
     };
 
+    $scope.toggleForceQualitySwitch = function () {
+        $scope.controlbar.forceQualitySwitch($scope.forceQualitySwitchSelected);
+    };
+
     $scope.toggleScheduleWhilePaused = function () {
         $scope.player.updateSettings({
             'streaming': {
diff --git a/samples/dash-if-reference-player/index.html b/samples/dash-if-reference-player/index.html
index aba93a1942..802fca9b58 100644
--- a/samples/dash-if-reference-player/index.html
+++ b/samples/dash-if-reference-player/index.html
@@ -246,6 +246,12 @@
                            ng-change="toggleVideoAutoSwitch()" ng-checked="videoAutoSwitchSelected">
                     Video Auto Switch
                 </label>
+                <label class="topcoat-checkbox" data-toggle="tooltip" data-placement="right"
+                       title="Forces quality switch to be immediatly effective">
+                    <input type="checkbox" id="forceQualitySwitchCB" ng-model="forceQualitySwitchSelected"
+                           ng-change="toggleForceQualitySwitch()" ng-checked="forceQualitySwitchSelected">
+                    Force Quality Switch
+                </label>
                 <label class="topcoat-checkbox" data-toggle="tooltip" data-placement="right"
                        title="ABR - Use custom ABR rules">
                     <input type="checkbox" id="customABRRules" ng-model="customABRRulesSelected"
diff --git a/src/core/events/CoreEvents.js b/src/core/events/CoreEvents.js
index 0cad0a4623..765b2589ee 100644
--- a/src/core/events/CoreEvents.js
+++ b/src/core/events/CoreEvents.js
@@ -44,6 +44,7 @@ class CoreEvents extends EventsBase {
         this.BUFFERING_COMPLETED = 'bufferingCompleted';
         this.BUFFER_CLEARED = 'bufferCleared';
         this.BYTES_APPENDED_END_FRAGMENT = 'bytesAppendedEndFragment';
+        this.BUFFER_REPLACEMENT_STARTED = 'bufferReplacementStarted';
         this.CHECK_FOR_EXISTENCE_COMPLETED = 'checkForExistenceCompleted';
         this.CURRENT_TRACK_CHANGED = 'currentTrackChanged';
         this.DATA_UPDATE_COMPLETED = 'dataUpdateCompleted';
@@ -70,7 +71,6 @@ class CoreEvents extends EventsBase {
         this.STREAM_REQUESTING_COMPLETED = 'streamRequestingCompleted';
         this.TEXT_TRACKS_QUEUE_INITIALIZED = 'textTracksQueueInitialized';
         this.TIME_SYNCHRONIZATION_COMPLETED = 'timeSynchronizationComplete';
-        this.TRACK_REPLACEMENT_STARTED = 'trackReplacementStarted';
         this.UPDATE_TIME_SYNC_OFFSET = 'updateTimeSyncOffset';
         this.URL_RESOLUTION_FAILED = 'urlResolutionFailed';
         this.VIDEO_CHUNK_RECEIVED = 'videoChunkReceived';
diff --git a/src/dash/controllers/RepresentationController.js b/src/dash/controllers/RepresentationController.js
index 6248b9898d..8b2caccd1b 100644
--- a/src/dash/controllers/RepresentationController.js
+++ b/src/dash/controllers/RepresentationController.js
@@ -57,7 +57,6 @@ function RepresentationController(config) {
     function setup() {
         resetInitialSettings();
 
-        eventBus.on(MediaPlayerEvents.QUALITY_CHANGE_REQUESTED, onQualityChanged, instance);
         eventBus.on(MediaPlayerEvents.MANIFEST_VALIDITY_CHANGED, onManifestValidityChanged, instance);
     }
 
@@ -94,7 +93,6 @@ function RepresentationController(config) {
     }
 
     function reset() {
-        eventBus.off(MediaPlayerEvents.QUALITY_CHANGE_REQUESTED, onQualityChanged, instance);
         eventBus.off(MediaPlayerEvents.MANIFEST_VALIDITY_CHANGED, onManifestValidityChanged, instance);
 
         resetInitialSettings();
@@ -289,8 +287,8 @@ function RepresentationController(config) {
         }
     }
 
-    function onQualityChanged(e) {
-        currentVoRepresentation = getRepresentationForQuality(e.newQuality);
+    function prepareQualityChange(newQuality) {
+        currentVoRepresentation = getRepresentationForQuality(newQuality);
         addRepresentationSwitch();
     }
 
@@ -312,7 +310,8 @@ function RepresentationController(config) {
         updateData,
         getCurrentRepresentation,
         getRepresentationForQuality,
-        reset: reset
+        prepareQualityChange,
+        reset
     };
 
     setup();
diff --git a/src/streaming/MediaPlayer.js b/src/streaming/MediaPlayer.js
index f91fd5079b..d82ac64fd5 100644
--- a/src/streaming/MediaPlayer.js
+++ b/src/streaming/MediaPlayer.js
@@ -868,13 +868,14 @@ function MediaPlayer() {
      *
      * @param {MediaType} type - 'video', 'audio' or 'image'
      * @param {number} value - the quality index, 0 corresponding to the lowest bitrate
+     * @param {boolean} replace - true if segments have to be replaced by segments of the new quality
      * @memberof module:MediaPlayer
      * @see {@link module:MediaPlayer#setAutoSwitchQualityFor setAutoSwitchQualityFor()}
      * @see {@link module:MediaPlayer#getQualityFor getQualityFor()}
      * @throws {@link module:MediaPlayer~STREAMING_NOT_INITIALIZED_ERROR STREAMING_NOT_INITIALIZED_ERROR} if called before initializePlayback function
      * @instance
      */
-    function setQualityFor(type, value) {
+    function setQualityFor(type, value, replace = false) {
         if (!streamingInitialized) {
             throw STREAMING_NOT_INITIALIZED_ERROR;
         }
@@ -888,7 +889,7 @@ function MediaPlayer() {
                 thumbnailController.setTrackByIndex(value);
             }
         }
-        abrController.setPlaybackQuality(type, streamController.getActiveStreamInfo(), value);
+        abrController.setPlaybackQuality(type, streamController.getActiveStreamInfo(), value, { replace: replace });
     }
 
     /**
diff --git a/src/streaming/Stream.js b/src/streaming/Stream.js
index 95c59244ce..2ea32163a1 100644
--- a/src/streaming/Stream.js
+++ b/src/streaming/Stream.js
@@ -657,6 +657,14 @@ function Stream(config) {
         }
     }
 
+    function prepareQualityChange(e) {
+        const processor = _getProcessorByType(e.mediaType);
+
+        if (processor) {
+            processor.prepareQualityChange(e);
+        }
+    }
+
     function addInlineEvents() {
         if (eventController) {
             const events = adapter.getEventsFor(streamInfo);
@@ -753,14 +761,22 @@ function Stream(config) {
     }
 
     function getProcessorForMediaInfo(mediaInfo) {
-        if (!mediaInfo) {
+        if (!mediaInfo || !mediaInfo.type) {
+            return null;
+        }
+
+        return _getProcessorByType(mediaInfo.type);
+    }
+
+    function _getProcessorByType(type) {
+        if (!type) {
             return null;
         }
 
         let processors = getProcessors();
 
         return processors.filter(function (processor) {
-            return (processor.getType() === mediaInfo.type);
+            return (processor.getType() === type);
         })[0];
     }
 
@@ -955,7 +971,8 @@ function Stream(config) {
         getHasFinishedBuffering,
         setPreloaded,
         startScheduleControllers,
-        prepareTrackChange
+        prepareTrackChange,
+        prepareQualityChange
     };
 
     setup();
diff --git a/src/streaming/StreamProcessor.js b/src/streaming/StreamProcessor.js
index dc95efec8b..bf2cf7f418 100644
--- a/src/streaming/StreamProcessor.js
+++ b/src/streaming/StreamProcessor.js
@@ -98,7 +98,6 @@ function StreamProcessor(config) {
         eventBus.on(Events.BUFFER_LEVEL_STATE_CHANGED, _onBufferLevelStateChanged, instance);
         eventBus.on(Events.BUFFER_CLEARED, _onBufferCleared, instance);
         eventBus.on(Events.SEEK_TARGET, _onSeekTarget, instance);
-        eventBus.on(Events.QUALITY_CHANGE_REQUESTED, _onQualityChanged, instance);
         eventBus.on(Events.FRAGMENT_LOADING_ABANDONED, _onFragmentLoadingAbandoned, instance);
         eventBus.on(Events.FRAGMENT_LOADING_COMPLETED, _onFragmentLoadingCompleted, instance);
         eventBus.on(Events.QUOTA_EXCEEDED, _onQuotaExceeded, instance);
@@ -240,7 +239,6 @@ function StreamProcessor(config) {
         eventBus.off(Events.BUFFER_LEVEL_STATE_CHANGED, _onBufferLevelStateChanged, instance);
         eventBus.off(Events.BUFFER_CLEARED, _onBufferCleared, instance);
         eventBus.off(Events.SEEK_TARGET, _onSeekTarget, instance);
-        eventBus.off(Events.QUALITY_CHANGE_REQUESTED, _onQualityChanged, instance);
         eventBus.off(Events.FRAGMENT_LOADING_ABANDONED, _onFragmentLoadingAbandoned, instance);
         eventBus.off(Events.FRAGMENT_LOADING_COMPLETED, _onFragmentLoadingCompleted, instance);
         eventBus.off(Events.SET_FRAGMENTED_TEXT_AFTER_DISABLED, _onSetFragmentedTextAfterDisabled, instance);
@@ -519,39 +517,94 @@ function StreamProcessor(config) {
      * @param {object} e
      * @private
      */
-    function _onQualityChanged(e) {
-        const representationInfo = getRepresentationInfo(e.newQuality);
+    function prepareQualityChange(e) {
+        logger.debug(`Preparing quality switch for type ${type}`);
+        const newQuality = e.newQuality;
 
+        // Stop scheduling until we are done with preparing the quality switch
+        scheduleController.clearScheduleTimer();
+
+        const representationInfo = getRepresentationInfo(newQuality);
         scheduleController.setCurrentRepresentation(representationInfo);
-        bufferController.prepareForQualityChange()
+        representationController.prepareQualityChange(newQuality);
+
+        // Abort the current request to avoid inconsistencies. A quality switch can also be triggered manually by the application.
+        // If we update the buffer values now, or initialize a request to the new init segment, the currently downloading media segment might "work" with wrong values.
+        // Everything that is already in the buffer queue is ok and will be handled by the corresponding function below depending on the switch mode.
+        fragmentModel.abortRequests();
+
+        // In any case we need to update the MSE.timeOffset
+        bufferController.updateBufferTimestampOffset(representationInfo)
             .then(() => {
-                // if we switch up in quality and need to replace existing parts in the buffer we need to adjust the buffer target
-                if (settings.get().streaming.buffer.fastSwitchEnabled) {
-                    const time = playbackController.getTime();
-                    let safeBufferLevel = 1.5;
-                    const request = fragmentModel.getRequests({
-                        state: FragmentModel.FRAGMENT_MODEL_EXECUTED,
-                        time: time + safeBufferLevel,
-                        threshold: 0
-                    })[0];
-
-                    if (request && !adapter.getIsTextTrack(mimeType)) {
-                        const bufferLevel = bufferController.getBufferLevel();
-                        const abandonmentState = abrController.getAbandonmentStateFor(streamInfo.id, type);
-
-                        if (request.quality < representationInfo.quality && bufferLevel >= safeBufferLevel && abandonmentState !== MetricsConstants.ABANDON_LOAD) {
-                            setExplicitBufferingTime(time + safeBufferLevel);
-                            scheduleController.setCheckPlaybackQuality(false);
-                        }
-                    }
+
+                // If the switch should occur immediately we need to replace existing stuff in the buffer
+                if (e.reason && e.reason.replace) {
+                    _prepareReplacementQualitySwitch();
+                }
+
+                // If fast switch is enabled we check if we are supposed to replace existing stuff in the buffer
+                else if (settings.get().streaming.buffer.fastSwitchEnabled) {
+                    _prepareForFastQualitySwitch(representationInfo);
+                }
+
+                // Default quality switch. We append the new quality to the already buffered stuff
+                else {
+                    _prepareForDefaultQualitySwitch();
                 }
 
                 dashMetrics.pushPlayListTraceMetrics(new Date(), PlayListTrace.REPRESENTATION_SWITCH_STOP_REASON);
                 dashMetrics.createPlaylistTraceMetrics(representationInfo.id, playbackController.getTime() * 1000, playbackController.getPlaybackRate());
             })
-            .catch((e) => {
-                logger.error(e);
+    }
+
+    function _prepareReplacementQualitySwitch() {
+
+        // Inform other classes like the GapController that we are replacing existing stuff
+        eventBus.trigger(Events.BUFFER_REPLACEMENT_STARTED, {
+            mediaType: type,
+            streamId: streamInfo.id
+        }, { mediaType: type, streamId: streamInfo.id });
+
+        // Abort appending segments to the buffer. Also adjust the appendWindow as we might have been in the progress of prebuffering stuff.
+        bufferController.prepareForReplacementQualitySwitch()
+            .then(() => {
+                _bufferClearedForReplacement();
             })
+            .catch(() => {
+                _bufferClearedForReplacement();
+            });
+    }
+
+    function _prepareForFastQualitySwitch(representationInfo) {
+        // if we switch up in quality and need to replace existing parts in the buffer we need to adjust the buffer target
+        const time = playbackController.getTime();
+        let safeBufferLevel = 1.5;
+        const request = fragmentModel.getRequests({
+            state: FragmentModel.FRAGMENT_MODEL_EXECUTED,
+            time: time + safeBufferLevel,
+            threshold: 0
+        })[0];
+
+        if (request && !adapter.getIsTextTrack(mimeType)) {
+            const bufferLevel = bufferController.getBufferLevel();
+            const abandonmentState = abrController.getAbandonmentStateFor(streamInfo.id, type);
+
+            if (request.quality < representationInfo.quality && bufferLevel >= safeBufferLevel && abandonmentState !== MetricsConstants.ABANDON_LOAD) {
+                const targetTime = time + safeBufferLevel;
+                setExplicitBufferingTime(targetTime);
+                scheduleController.setCheckPlaybackQuality(false);
+                scheduleController.startScheduleTimer();
+            } else {
+                _prepareForDefaultQualitySwitch();
+            }
+        } else {
+            scheduleController.startScheduleTimer();
+        }
+    }
+
+    function _prepareForDefaultQualitySwitch() {
+        // We might have aborted the current request. We need to set an explicit buffer time based on what we already have in the buffer.
+        _bufferClearedForNonReplacement()
     }
 
     /**
@@ -876,7 +929,7 @@ function StreamProcessor(config) {
         // when we are supposed to replace it does not matter if buffering is already completed
         if (shouldReplace) {
             // Inform other classes like the GapController that we are replacing existing stuff
-            eventBus.trigger(Events.TRACK_REPLACEMENT_STARTED, {
+            eventBus.trigger(Events.BUFFER_REPLACEMENT_STARTED, {
                 mediaType: type,
                 streamId: streamInfo.id
             }, { mediaType: type, streamId: streamInfo.id });
@@ -892,20 +945,20 @@ function StreamProcessor(config) {
                     return bufferController.updateBufferTimestampOffset(representationInfo);
                 })
                 .then(() => {
-                    _bufferClearedForReplacementTrackSwitch();
+                    _bufferClearedForReplacement();
                 })
                 .catch(() => {
-                    _bufferClearedForReplacementTrackSwitch();
+                    _bufferClearedForReplacement();
                 });
         } else {
             // We do not replace anything that is already in the buffer. Still we need to prepare the buffer for the track switch
             bufferController.prepareForNonReplacementTrackSwitch(mediaInfo.codec)
                 .then(() => {
-                    _bufferClearedForNonReplacementTrackSwitch();
+                    _bufferClearedForNonReplacement();
                 })
                 .catch
                 (() => {
-                    _bufferClearedForNonReplacementTrackSwitch();
+                    _bufferClearedForNonReplacement();
                 });
         }
     }
@@ -914,7 +967,7 @@ function StreamProcessor(config) {
      * For an instant track switch we need to adjust the buffering time after the buffer has been pruned.
      * @private
      */
-    function _bufferClearedForReplacementTrackSwitch() {
+    function _bufferClearedForReplacement() {
         const targetTime = playbackController.getTime();
 
         if (settings.get().streaming.buffer.flushBufferAtTrackSwitch) {
@@ -928,7 +981,7 @@ function StreamProcessor(config) {
         scheduleController.startScheduleTimer();
     }
 
-    function _bufferClearedForNonReplacementTrackSwitch() {
+    function _bufferClearedForNonReplacement() {
         const time = playbackController.getTime();
         const targetTime = bufferController.getContinuousBufferTimeForTargetTime(time);
 
@@ -1010,6 +1063,7 @@ function StreamProcessor(config) {
         selectMediaInfo,
         addMediaInfo,
         prepareTrackSwitch,
+        prepareQualityChange,
         getMediaInfoArr,
         getMediaInfo,
         getMediaSource,
diff --git a/src/streaming/controllers/BufferController.js b/src/streaming/controllers/BufferController.js
index 30cf5b8f42..01e4c1b761 100644
--- a/src/streaming/controllers/BufferController.js
+++ b/src/streaming/controllers/BufferController.js
@@ -32,7 +32,6 @@ import Constants from '../constants/Constants';
 import MetricsConstants from '../constants/MetricsConstants';
 import FragmentModel from '../models/FragmentModel';
 import SourceBufferSink from '../SourceBufferSink';
-import AbrController from './AbrController';
 import EventBus from '../../core/EventBus';
 import Events from '../../core/events/Events';
 import FactoryMaker from '../../core/FactoryMaker';
@@ -67,7 +66,6 @@ function BufferController(config) {
 
     let instance,
         logger,
-        requiredQuality,
         isBufferingCompleted,
         bufferLevel,
         criticalBufferLevel,
@@ -100,8 +98,6 @@ function BufferController(config) {
     function initialize(mediaSource) {
         setMediaSource(mediaSource);
 
-        requiredQuality = abrController.getQualityFor(type, streamInfo.id);
-
         eventBus.on(Events.INIT_FRAGMENT_LOADED, _onInitFragmentLoaded, instance);
         eventBus.on(Events.MEDIA_FRAGMENT_LOADED, _onMediaFragmentLoaded, instance);
         eventBus.on(Events.STREAM_REQUESTING_COMPLETED, _onStreamRequestingCompleted, instance);
@@ -169,8 +165,9 @@ function BufferController(config) {
                 return;
             }
 
+            const requiredQuality = abrController.getQualityFor(type, streamInfo.id);
             sourceBufferSink = SourceBufferSink(context).create({ mediaSource, textController });
-            _initializeSink(mediaInfo, oldBufferSinks)
+            _initializeSink(mediaInfo, oldBufferSinks, requiredQuality)
                 .then(() => {
                     return updateBufferTimestampOffset(_getRepresentationInfo(requiredQuality));
                 })
@@ -185,7 +182,7 @@ function BufferController(config) {
         });
     }
 
-    function _initializeSink(mediaInfo, oldBufferSinks) {
+    function _initializeSink(mediaInfo, oldBufferSinks, requiredQuality) {
         const selectedRepresentation = _getRepresentationInfo(requiredQuality);
 
         if (oldBufferSinks && oldBufferSinks[type] && (type === Constants.VIDEO || type === Constants.AUDIO)) {
@@ -374,12 +371,6 @@ function BufferController(config) {
         }
     }
 
-    function prepareForQualityChange(newQuality, representationInfo) {
-        requiredQuality = newQuality;
-
-        return updateBufferTimestampOffset(representationInfo);
-    }
-
     //**********************************************************************
     // START Buffer Level, State & Sufficiency Handling.
     //**********************************************************************
@@ -414,6 +405,25 @@ function BufferController(config) {
         });
     }
 
+    function prepareForReplacementQualitySwitch() {
+        return new Promise((resolve, reject) => {
+            sourceBufferSink.abort()
+                .then(() => {
+                    return updateAppendWindow();
+                })
+                .then(() => {
+                    return pruneAllSafely();
+                })
+                .then(() => {
+                    setIsBufferingCompleted(false);
+                    resolve();
+                })
+                .catch((e) => {
+                    reject(e);
+                });
+        });
+    }
+
     function prepareForNonReplacementTrackSwitch(codec) {
         return new Promise((resolve, reject) => {
             updateAppendWindow()
@@ -989,7 +999,6 @@ function BufferController(config) {
     function resetInitialSettings(errored, keepBuffers) {
         criticalBufferLevel = Number.POSITIVE_INFINITY;
         bufferState = undefined;
-        requiredQuality = AbrController.QUALITY_DEFAULT;
         maximumIndex = Number.POSITIVE_INFINITY;
         maxAppendedIndex = 0;
         appendedBytesInfo = null;
@@ -1049,9 +1058,9 @@ function BufferController(config) {
         getIsPruningInProgress,
         reset,
         prepareForPlaybackSeek,
-        prepareForQualityChange,
         prepareForReplacementTrackSwitch,
         prepareForNonReplacementTrackSwitch,
+        prepareForReplacementQualitySwitch,
         updateAppendWindow,
         getAllRangesWithSafetyFactor,
         getContinuousBufferTimeForTargetTime,
diff --git a/src/streaming/controllers/GapController.js b/src/streaming/controllers/GapController.js
index 308e62629f..31d2beca46 100644
--- a/src/streaming/controllers/GapController.js
+++ b/src/streaming/controllers/GapController.js
@@ -101,16 +101,16 @@ function GapController() {
         eventBus.on(Events.WALLCLOCK_TIME_UPDATED, _onWallclockTimeUpdated, this);
         eventBus.on(Events.INITIAL_STREAM_SWITCH, _onInitialStreamSwitch, this);
         eventBus.on(Events.PLAYBACK_SEEKING, _onPlaybackSeeking, this);
-        eventBus.on(Events.TRACK_REPLACEMENT_STARTED, _onTrackReplacementStarted, instance);
-        eventBus.on(Events.TRACK_CHANGE_RENDERED, _onTrackChangeRendered, instance);
+        eventBus.on(Events.BUFFER_REPLACEMENT_STARTED, _onBufferReplacementStarted, instance);
+        eventBus.on(Events.TRACK_CHANGE_RENDERED, _onBufferReplacementEnded, instance);
     }
 
     function unregisterEvents() {
         eventBus.off(Events.WALLCLOCK_TIME_UPDATED, _onWallclockTimeUpdated, this);
         eventBus.off(Events.INITIAL_STREAM_SWITCH, _onInitialStreamSwitch, this);
         eventBus.off(Events.PLAYBACK_SEEKING, _onPlaybackSeeking, this);
-        eventBus.off(Events.TRACK_REPLACEMENT_STARTED, _onTrackReplacementStarted, instance);
-        eventBus.on(Events.BYTES_APPENDED_END_FRAGMENT, _onTrackChangeRendered, instance);
+        eventBus.off(Events.BUFFER_REPLACEMENT_STARTED, _onBufferReplacementStarted, instance);
+        eventBus.on(Events.BYTES_APPENDED_END_FRAGMENT, _onBufferReplacementEnded, instance);
     }
 
     function _onPlaybackSeeking() {
@@ -126,7 +126,7 @@ function GapController() {
      * @param {object} e
      * @private
      */
-    function _onTrackReplacementStarted(e) {
+    function _onBufferReplacementStarted(e) {
         try {
             if (e.streamId !== streamController.getActiveStreamInfo().id || !e.mediaType) {
                 return;
@@ -140,7 +140,7 @@ function GapController() {
         }
     }
 
-    function _onTrackChangeRendered(e) {
+    function _onBufferReplacementEnded(e) {
         if (!e || !e.mediaType) {
             return;
         }
diff --git a/src/streaming/controllers/StreamController.js b/src/streaming/controllers/StreamController.js
index a212b9f6cb..fae1667dd2 100644
--- a/src/streaming/controllers/StreamController.js
+++ b/src/streaming/controllers/StreamController.js
@@ -169,6 +169,7 @@ function StreamController() {
         eventBus.on(MediaPlayerEvents.METRIC_ADDED, onMetricAdded, instance);
         eventBus.on(MediaPlayerEvents.MANIFEST_VALIDITY_CHANGED, onManifestValidityChanged, instance);
         eventBus.on(MediaPlayerEvents.BUFFER_LEVEL_UPDATED, _onBufferLevelUpdated, instance);
+        eventBus.on(MediaPlayerEvents.QUALITY_CHANGE_REQUESTED, _onQualityChanged, instance);
 
         eventBus.on(Events.KEY_SESSION_UPDATED, _onKeySessionUpdated, instance);
         eventBus.on(Events.MANIFEST_UPDATED, _onManifestUpdated, instance);
@@ -189,6 +190,7 @@ function StreamController() {
         eventBus.off(MediaPlayerEvents.METRIC_ADDED, onMetricAdded, instance);
         eventBus.off(MediaPlayerEvents.MANIFEST_VALIDITY_CHANGED, onManifestValidityChanged, instance);
         eventBus.off(MediaPlayerEvents.BUFFER_LEVEL_UPDATED, _onBufferLevelUpdated, instance);
+        eventBus.off(MediaPlayerEvents.QUALITY_CHANGE_REQUESTED, _onQualityChanged, instance);
 
         eventBus.off(Events.KEY_SESSION_UPDATED, _onKeySessionUpdated, instance);
         eventBus.off(Events.MANIFEST_UPDATED, _onManifestUpdated, instance);
@@ -700,6 +702,22 @@ function StreamController() {
         }
     }
 
+    /**
+     * When the quality is changed in the currently active stream and we do an aggressive replacement we must stop prebuffering. This is similar to a replacing track switch
+     * Otherwise preloading can go on.
+     * @param e
+     * @private
+     */
+    function _onQualityChanged(e) {
+        if (e.streamInfo.id === activeStream.getId() && e.reason && e.reason.replace) {
+            _deactivateAllPreloadingStreams();
+        }
+
+        const stream = getStreamById(e.streamInfo.id);
+
+        stream.prepareQualityChange(e);
+    }
+
     /**
      * Update the DVR window when the wallclock time has updated
      * @private
diff --git a/test/unit/dash.controllers.RepresentationController.js b/test/unit/dash.controllers.RepresentationController.js
index f15a8d65f3..70e38ed6d5 100644
--- a/test/unit/dash.controllers.RepresentationController.js
+++ b/test/unit/dash.controllers.RepresentationController.js
@@ -124,24 +124,24 @@ describe('RepresentationController', function () {
                 expect(representationController.getRepresentationForQuality(150)).to.equal(null);
             });
 
-            it('when a MANIFEST_VALIDITY_CHANGED event occurs, should update current representation', function () {
-                let currentRepresentation = representationController.getCurrentRepresentation();
-                expect(currentRepresentation.adaptation.period.duration).to.equal(100); // jshint ignore:line
-                eventBus.trigger(Events.MANIFEST_VALIDITY_CHANGED, { sender: {}, newDuration: 150 });
-
-                expect(currentRepresentation.adaptation.period.duration).to.equal(150); // jshint ignore:line
-            });
-
-            it('when a QUALITY_CHANGE_REQUESTED event occurs, should update current representation', function () {
+            it('should update current representation when preparing a quality change', function () {
                 let currentRepresentation = representationController.getCurrentRepresentation();
                 expect(currentRepresentation.index).to.equal(0); // jshint ignore:line
 
-                eventBus.trigger(Events.QUALITY_CHANGE_REQUESTED, {mediaType: testType, streamInfo: streamProcessor.getStreamInfo(), oldQuality: 0, newQuality: 1});
+                representationController.prepareQualityChange(1);
 
                 currentRepresentation = representationController.getCurrentRepresentation();
                 expect(currentRepresentation.index).to.equal(1); // jshint ignore:line
             });
 
+            it('when a MANIFEST_VALIDITY_CHANGED event occurs, should update current representation', function () {
+                let currentRepresentation = representationController.getCurrentRepresentation();
+                expect(currentRepresentation.adaptation.period.duration).to.equal(100); // jshint ignore:line
+                eventBus.trigger(Events.MANIFEST_VALIDITY_CHANGED, { sender: {}, newDuration: 150 });
+
+                expect(currentRepresentation.adaptation.period.duration).to.equal(150); // jshint ignore:line
+            });
+
         });
 
         describe('when a call to reset is done', function () {