diff --git a/config/alfresco/content-services-context.xml b/config/alfresco/content-services-context.xml
index fea1861dfa..b16ac538fc 100644
--- a/config/alfresco/content-services-context.xml
+++ b/config/alfresco/content-services-context.xml
@@ -401,6 +401,7 @@
       <property name="registerTransformer">
          <value>true</value>
       </property>
+       <property name="retryTransformOnDifferentMimeType" value="${content.transformer.retryOn.different.mimetype}"/>
    </bean>
    
    <!-- Abstract bean definition defining base definition for all transformer that are not registered.
diff --git a/config/alfresco/repository.properties b/config/alfresco/repository.properties
index 63dcca680d..cd392e07ee 100644
--- a/config/alfresco/repository.properties
+++ b/config/alfresco/repository.properties
@@ -1086,4 +1086,9 @@ system.patch.sharedFolder.cronExpression=0 0 0 ? 1 1 2030
 people.search.honor.hint.useCQ=true
 
 # Delays cron jobs after bootstrap to allow server to fully come up before jobs start
-system.cronJob.startDelayMinutes=1
\ No newline at end of file
+system.cronJob.startDelayMinutes=1
+
+#
+# Enable transformation retrying if the file has MIME type differ than file extension.
+#
+content.transformer.retryOn.different.mimetype=true
\ No newline at end of file
diff --git a/source/java/org/alfresco/repo/content/transform/AbstractContentTransformer2.java b/source/java/org/alfresco/repo/content/transform/AbstractContentTransformer2.java
index 03672e3ffb..d494d4765f 100644
--- a/source/java/org/alfresco/repo/content/transform/AbstractContentTransformer2.java
+++ b/source/java/org/alfresco/repo/content/transform/AbstractContentTransformer2.java
@@ -45,6 +45,7 @@ public abstract class AbstractContentTransformer2 extends AbstractContentTransfo
     
     private ContentTransformerRegistry registry;
     private boolean registerTransformer;
+    private boolean retryTransformOnDifferentMimeType;
 
     private static ThreadLocal<Integer> depth = new ThreadLocal<Integer>()
     {
@@ -262,15 +263,51 @@ public abstract class AbstractContentTransformer2 extends AbstractContentTransfo
                 }
                 else
                 {
-               transformerDebug.debug("          Failed: Mime type was '"+differentType+"'", e);
-                   throw new ContentIOException("Content conversion failed: \n" +
-                         "   reader: " + reader + "\n" +
-                         "   writer: " + writer + "\n" +
-                         "   options: " + options.toString(false) + "\n" +
-                         "   limits: " + getLimits(reader, writer, options) + "\n" +
-                         "   claimed mime type: " + reader.getMimetype() + "\n" +
-                         "   detected mime type: " + differentType,
-                         e);
+                    transformerDebug.debug("          Failed: Mime type was '"+differentType+"'", e);
+
+                    if (this.retryTransformOnDifferentMimeType)
+                    {
+                        // MNT-11015 fix.
+                        // Set a new reader to refresh the input stream.
+                        reader = reader.getReader();
+                        // set the actual file MIME type detected by Tika for content reader
+                        reader.setMimetype(differentType);
+
+                        // Get correct transformer according actual file MIME type and try to transform file with
+                        // actual transformer
+                        ContentTransformer transformer = this.registry.getTransformer(differentType, reader.getSize(),
+                                                                                     targetMimetype, options);
+                        if (null != transformer)
+                        {
+                            transformer.transform(reader, writer, options);
+                        }
+                        else
+                        {
+                            transformerDebug.debug("          Failed", e);
+                            throw new ContentIOException("Content conversion failed: \n" +
+                                    "   reader: " + reader + "\n" +
+                                    "   writer: " + writer + "\n" +
+                                    "   options: " + options.toString(false) + "\n" +
+                                    "   limits: " + getLimits(reader, writer, options) + "\n" +
+                                    "   claimed mime type: " + reader.getMimetype() + "\n" +
+                                    "   detected mime type: " + differentType + "\n" +
+                                    "   transformer not found" + "\n",
+                                    e
+                            );
+                        }
+                    }
+                    else
+                    {
+                        throw new ContentIOException("Content conversion failed: \n" +
+                                "   reader: " + reader + "\n" +
+                                "   writer: " + writer + "\n" +
+                                "   options: " + options.toString(false) + "\n" +
+                                "   limits: " + getLimits(reader, writer, options) + "\n" +
+                                "   claimed mime type: " + reader.getMimetype() + "\n" +
+                                "   detected mime type: " + differentType,
+                                e
+                        );
+                    }
                 }
             }
             finally
@@ -379,4 +416,9 @@ public abstract class AbstractContentTransformer2 extends AbstractContentTransfo
             transformerConfig.getStatistics(null, sourceMimetype, targetMimetype, true).recordError(transformationTime);
         }
     }
+
+    public void setRetryTransformOnDifferentMimeType(boolean retryTransformOnDifferentMimeType)
+    {
+        this.retryTransformOnDifferentMimeType = retryTransformOnDifferentMimeType;
+    }
 }
diff --git a/source/test-java/org/alfresco/Repository01TestSuite.java b/source/test-java/org/alfresco/Repository01TestSuite.java
index 387130018c..e2d40cccc9 100644
--- a/source/test-java/org/alfresco/Repository01TestSuite.java
+++ b/source/test-java/org/alfresco/Repository01TestSuite.java
@@ -420,4 +420,9 @@ public class Repository01TestSuite extends TestSuite
         suite.addTest(new JUnit4TestAdapter(org.alfresco.filesys.auth.cifs.CifsAuthenticatorKerberosTest.class));		
         suite.addTest(new JUnit4TestAdapter(org.alfresco.filesys.auth.cifs.CifsAuthenticatorPassthruTest.class));
     }
+
+    static void tests65(TestSuite suite)
+    {
+        suite.addTestSuite(org.alfresco.repo.content.transform.DifferrentMimeTypeTest.class);
+    }
 }
diff --git a/source/test-java/org/alfresco/Repository65TestSuite.java b/source/test-java/org/alfresco/Repository65TestSuite.java
new file mode 100644
index 0000000000..c43994d7fe
--- /dev/null
+++ b/source/test-java/org/alfresco/Repository65TestSuite.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2005-2014 Alfresco Software Limited.
+ *
+ * This file is part of Alfresco
+ *
+ * Alfresco is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Alfresco is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.alfresco;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+/**
+ * See {@link RepositoryMisc01TestSuite}
+ *
+ * @Author Alexey Bogdanov
+ */
+public class Repository65TestSuite extends TestSuite
+{
+    public static Test suite()
+    {
+        TestSuite suite = new TestSuite();
+        Repository01TestSuite.tests65(suite);
+        return suite;
+    }
+}
diff --git a/source/test-java/org/alfresco/repo/content/transform/DifferrentMimeTypeTest.java b/source/test-java/org/alfresco/repo/content/transform/DifferrentMimeTypeTest.java
new file mode 100644
index 0000000000..ff7262fccc
--- /dev/null
+++ b/source/test-java/org/alfresco/repo/content/transform/DifferrentMimeTypeTest.java
@@ -0,0 +1,227 @@
+/*
+ * Copyright (C) 2005-2010 Alfresco Software Limited.
+ *
+ * This file is part of Alfresco
+ *
+ * Alfresco is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Alfresco is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.alfresco.repo.content.transform;
+
+import junit.framework.TestCase;
+
+import org.alfresco.model.ContentModel;
+import org.alfresco.repo.content.MimetypeMap;
+import org.alfresco.repo.content.filestore.*;
+import org.alfresco.repo.model.Repository;
+import org.alfresco.repo.security.authentication.AuthenticationUtil;
+import org.alfresco.repo.transaction.RetryingTransactionHelper;
+import org.alfresco.service.ServiceRegistry;
+import org.alfresco.service.cmr.repository.*;
+import org.alfresco.service.namespace.NamespaceService;
+import org.alfresco.service.namespace.QName;
+import org.alfresco.service.transaction.TransactionService;
+import org.alfresco.util.ApplicationContextHelper;
+import org.alfresco.util.TempFileProvider;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.junit.After;
+import org.junit.Before;
+import org.springframework.context.ApplicationContext;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.Serializable;
+import java.util.*;
+
+
+/**
+ * Tests the ContentTransformer correct work if the file extension is different from its MIME type
+ */
+public class DifferrentMimeTypeTest extends TestCase
+{
+    private static Log log = LogFactory.getLog(DifferrentMimeTypeTest.class);
+
+    private ContentTransformer contentTransformer;
+    private TransformationOptions options;
+    private ServiceRegistry serviceRegistry;
+    private MimetypeService mimetypeService;
+    private TransformerDebug transformerDebug;
+    private TransformerConfig transformerConfig;
+    private ContentTransformerRegistry registry;
+    private static Repository repositoryHelper;
+    private File testFile;
+    private File outputFile;
+    private TransactionService transactionService;
+    private NodeRef contentNodeRef;
+    private NodeService nodeService;
+    private LinkedList<NodeRef> nodesToDeleteAfterTest = new LinkedList<>();
+    private ContentService contentService;
+
+    @Before
+    public void setUp() throws Exception
+    {
+        ApplicationContext ctx = ApplicationContextHelper.getApplicationContext();
+        serviceRegistry = (ServiceRegistry) ctx.getBean(ServiceRegistry.SERVICE_REGISTRY);
+        mimetypeService = serviceRegistry.getMimetypeService();
+        transformerDebug = (TransformerDebug) ctx.getBean("transformerDebug");
+        transformerConfig = (TransformerConfig) ctx.getBean("transformerConfig");
+        registry = (ContentTransformerRegistry) ctx.getBean("contentTransformerRegistry");
+        transactionService = serviceRegistry.getTransactionService();
+        repositoryHelper = (Repository) ctx.getBean("repositoryHelper");
+        nodeService = serviceRegistry.getNodeService();
+        contentService = serviceRegistry.getContentService();
+
+        // Load the MS Word 2003 .doc file with incorrect extension
+        testFile = AbstractContentTransformerTest.loadNamedQuickTestFile("quick-differentMimetype.docx");
+        options = new TransformationOptions();
+        this.createContentNodeRef();
+    }
+
+    public void testDifferentMimeType() throws IOException
+    {
+
+        final QName propertyQName = ContentModel.PROP_CONTENT;
+        String sourceMimeType = mimetypeService.guessMimetype(testFile.getName());
+        String targetMimeType = MimetypeMap.MIMETYPE_IMAGE_JPEG;
+
+        // mimetypeService.guessMimetype returns file mime type based entirely on the file extension
+        assertEquals("Incorrect file MIME type or guessMimetype#MimetypeService implementation was changed ",
+                MimetypeMap.MIMETYPE_OPENXML_WORDPROCESSING, sourceMimeType);
+
+        AuthenticationUtil.RunAsWork<ContentReader> createTargetWork = new AuthenticationUtil.RunAsWork<ContentReader>()
+        {
+            @Override
+            public ContentReader doWork() throws Exception
+            {
+                return contentService.getReader(contentNodeRef, propertyQName);
+            }
+        };
+
+        ContentReader contentReader =  AuthenticationUtil.runAs(createTargetWork, AuthenticationUtil.getSystemUserName());
+        assertNotNull("content reader not present ", contentReader);
+
+        String outputFileExtension = mimetypeService.getExtension(targetMimeType);
+        outputFile = TempFileProvider.createTempFile("DifferentMimeTypeTest-results-", outputFileExtension);
+        ContentWriter outputWriter = new FileContentWriter(outputFile);
+
+        contentReader.setMimetype(sourceMimeType);
+        outputWriter.setMimetype(targetMimeType);
+
+        contentTransformer = this.registry.getTransformer(sourceMimeType, contentReader.getSize(), targetMimeType, options);
+        assertNotNull("contentTransformer not present", contentTransformer);
+
+        // Try to transform file with inaccurate MIME type
+        contentTransformer.transform(contentReader.getReader(), outputWriter, options);
+        
+        // After successful transformation image size should be grater than 0
+        assertTrue("File transformation failed. Output file size is '0'", outputWriter.getSize() > 0);
+    }
+
+    public void testSetUp()
+    {
+        assertNotNull("MimetypeMap not present", this.mimetypeService);
+        assertNotNull("ServiceRegistry not present", serviceRegistry);
+        assertNotNull("TransformerDebug not present", transformerDebug);
+        assertNotNull("TransformerConfig not present", transformerConfig);
+        assertNotNull("Transformer options not present", options);
+        assertNotNull("transactionService not present", transactionService);
+        assertNotNull("repositoryHelper not present", repositoryHelper);
+        assertNotNull("nodeService not present", nodeService);
+        assertNotNull("contentService not present", contentService);
+        assertNotNull("contentNodeRef not present", contentNodeRef);
+        assertNotNull("testFile was not created", testFile);
+    }
+
+
+    private void createContentNodeRef()
+    {
+        AuthenticationUtil.RunAsWork<NodeRef> createTargetWork = new AuthenticationUtil.RunAsWork<NodeRef>()
+        {
+            @Override
+            public NodeRef doWork() throws Exception
+            {
+                if (log.isDebugEnabled())
+                {
+                    log.debug("Creating temporary NodeRefs for testing.");
+                }
+
+                final NodeRef companyHome = repositoryHelper.getCompanyHome();
+                // Create a folder
+                Map<QName, Serializable> folderProps = new HashMap<>();
+                folderProps.put(ContentModel.PROP_NAME, this.getClass().getSimpleName() + System.currentTimeMillis());
+                NodeRef folderNodeRef = nodeService.createNode(companyHome, ContentModel.ASSOC_CONTAINS,
+                        ContentModel.ASSOC_CONTAINS, ContentModel.TYPE_FOLDER, folderProps).getChildRef();
+
+                // Mark folder for removing after test
+                nodesToDeleteAfterTest.add(folderNodeRef);
+
+                String fileName = testFile.getName();
+                Map<QName, Serializable> props = new HashMap<>();
+                props.put(ContentModel.PROP_NAME, fileName);
+
+                NodeRef node = nodeService.createNode(
+                        folderNodeRef,
+                        ContentModel.ASSOC_CONTAINS,
+                        QName.createQName(NamespaceService.CONTENT_MODEL_1_0_URI, fileName),
+                        ContentModel.TYPE_CONTENT,
+                        props).getChildRef();
+
+                // node should be removed after tests
+                nodesToDeleteAfterTest.add(node);
+
+                ContentWriter writer = contentService.getWriter(node, ContentModel.PROP_CONTENT, true);
+                String targetMimeType = mimetypeService.guessMimetype(fileName);
+
+                writer.setMimetype(targetMimeType);
+                writer.setEncoding("UTF-8");
+                writer.putContent(testFile);
+
+                return node;
+            }
+        };
+
+        contentNodeRef = AuthenticationUtil.runAs(createTargetWork, AuthenticationUtil.getSystemUserName());
+        this.nodesToDeleteAfterTest.add(contentNodeRef);
+    }
+
+    @After
+    public void deleteTemporaryNodeRefsAndTempFiles()
+    {
+        // Tidy up the test nodes we created
+        RetryingTransactionHelper.RetryingTransactionCallback<Void> deleteNodeCallback = new RetryingTransactionHelper.RetryingTransactionCallback<Void>()
+        {
+            public Void execute() throws Throwable
+            {
+                // Delete them in reverse order.
+                for (Iterator<NodeRef> iter = nodesToDeleteAfterTest.descendingIterator(); iter.hasNext(); )
+                {
+                    NodeRef nextNodeToDelete = iter.next();
+
+                    if (nodeService.exists(nextNodeToDelete))
+                    {
+                        if (log.isDebugEnabled())
+                        {
+                            log.debug("Deleting temporary node " + nextNodeToDelete);
+                        }
+                        nodeService.deleteNode(nextNodeToDelete);
+                    }
+                }
+                return null;
+            }
+        };
+        transactionService.getRetryingTransactionHelper().doInTransaction(deleteNodeCallback);
+
+        outputFile.deleteOnExit();
+    }
+}
diff --git a/source/test-resources/quick/quick-differentMimetype.docx b/source/test-resources/quick/quick-differentMimetype.docx
new file mode 100644
index 0000000000..eb307fb218
Binary files /dev/null and b/source/test-resources/quick/quick-differentMimetype.docx differ