diff --git a/libs/flake/text/KoSvgTextShapeMarkupConverter.cpp b/libs/flake/text/KoSvgTextShapeMarkupConverter.cpp
index 5fca7ffea3..c532714ef5 100644
--- a/libs/flake/text/KoSvgTextShapeMarkupConverter.cpp
+++ b/libs/flake/text/KoSvgTextShapeMarkupConverter.cpp
@@ -1,339 +1,365 @@
 /*
  *  Copyright (c) 2017 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program 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 General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "KoSvgTextShapeMarkupConverter.h"
 
 #include "klocalizedstring.h"
 #include "kis_assert.h"
 #include "kis_debug.h"
 
 #include <QBuffer>
 #include <QStringList>
 #include <QXmlStreamReader>
 #include <QXmlStreamWriter>
 
 #include <KoSvgTextShape.h>
 #include <KoXmlWriter.h>
 #include <KoXmlReader.h>
 #include <KoDocumentResourceManager.h>
 
 #include <SvgParser.h>
 #include <SvgWriter.h>
 #include <SvgSavingContext.h>
 #include <SvgGraphicContext.h>
 
 #include <html/HtmlSavingContext.h>
 #include <html/HtmlWriter.h>
 
 
 struct KoSvgTextShapeMarkupConverter::Private {
     Private(KoSvgTextShape *_shape) : shape(_shape) {}
 
     KoSvgTextShape *shape;
 
     QStringList errors;
     QStringList warnings;
 
     void clearErrors() {
         errors.clear();
         warnings.clear();
     }
 };
 
 KoSvgTextShapeMarkupConverter::KoSvgTextShapeMarkupConverter(KoSvgTextShape *shape)
     : d(new Private(shape))
 {
 }
 
 KoSvgTextShapeMarkupConverter::~KoSvgTextShapeMarkupConverter()
 {
 }
 
 bool KoSvgTextShapeMarkupConverter::convertToSvg(QString *svgText, QString *stylesText)
 {
     d->clearErrors();
 
     QBuffer shapesBuffer;
     QBuffer stylesBuffer;
 
     shapesBuffer.open(QIODevice::WriteOnly);
     stylesBuffer.open(QIODevice::WriteOnly);
 
     {
         SvgSavingContext savingContext(shapesBuffer, stylesBuffer);
         savingContext.setStrippedTextMode(true);
         SvgWriter writer({d->shape});
         writer.saveDetached(savingContext);
     }
 
     shapesBuffer.close();
     stylesBuffer.close();
 
     *svgText = QString::fromUtf8(shapesBuffer.data());
     *stylesText = QString::fromUtf8(stylesBuffer.data());
 
     return true;
 }
 
 bool KoSvgTextShapeMarkupConverter::convertFromSvg(const QString &svgText, const QString &stylesText,
                                                    const QRectF &boundsInPixels, qreal pixelsPerInch)
 {
 
     qDebug() << "convertFromSvg. text:" << svgText << "styles:" << stylesText << "bounds:" << boundsInPixels << "ppi:" << pixelsPerInch;
 
     d->clearErrors();
 
     KoXmlDocument doc;
     QString errorMessage;
     int errorLine = 0;
     int errorColumn = 0;
 
     const QString fullText = QString("<svg>\n%1\n%2\n</svg>\n").arg(stylesText).arg(svgText);
 
     if (!doc.setContent(fullText, &errorMessage, &errorLine, &errorColumn)) {
         d->errors << QString("line %1, col %2: %3").arg(errorLine).arg(errorColumn).arg(errorMessage);
         return false;
     }
 
     d->shape->resetTextShape();
 
     KoDocumentResourceManager resourceManager;
     SvgParser parser(&resourceManager);
     parser.setResolution(boundsInPixels, pixelsPerInch);
 
     KoXmlElement root = doc.documentElement();
     KoXmlNode node = root.firstChild();
 
     bool textNodeFound = false;
 
     for (; !node.isNull(); node = node.nextSibling()) {
         KoXmlElement el = node.toElement();
         if (el.isNull()) continue;
 
         if (el.tagName() == "defs") {
             parser.parseDefsElement(el);
         }
         else if (el.tagName() == "text") {
             if (textNodeFound) {
                 d->errors << i18n("More than one 'text' node found!");
                 return false;
             }
 
             KoShape *shape = parser.parseTextElement(el, d->shape);
             KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(shape == d->shape, false);
             textNodeFound = true;
             break;
         } else {
             d->errors << i18n("Unknown node of type \'%1\' found!", el.tagName());
             return false;
         }
     }
 
     if (!textNodeFound) {
         d->errors << i18n("No \'text\' node found!");
         return false;
     }
 
     return true;
 
 }
 
 bool KoSvgTextShapeMarkupConverter::convertToHtml(QString *htmlText)
 {
     d->clearErrors();
 
     QBuffer shapesBuffer;
     shapesBuffer.open(QIODevice::WriteOnly);
     {
         HtmlWriter writer({d->shape});
         if (!writer.save(shapesBuffer)) {
             d->errors = writer.errors();
             d->warnings = writer.warnings();
             return false;
         }
     }
 
     shapesBuffer.close();
 
     *htmlText = QString(shapesBuffer.data());
 
     qDebug() << "\t\t" << *htmlText;
 
     return true;
 }
 
 bool KoSvgTextShapeMarkupConverter::convertFromHtml(const QString &htmlText, QString *svgText, QString *styles)
 {
 
     qDebug() << ">>>>>>>>>>>" << htmlText;
 
     QBuffer svgBuffer;
     svgBuffer.open(QIODevice::WriteOnly);
 
     QXmlStreamReader htmlReader(htmlText);
     QXmlStreamWriter svgWriter(&svgBuffer);
 
     svgWriter.setAutoFormatting(true);
 
     QStringRef elementName;
 
     bool newLine = false;
     int lineCount = 0;
     QString bodyEm = "1em";
     QString em;
     QString p("p");
+    //previous style string is for keeping formatting proper on linebreaks and appendstyle is for specific tags
+    QString previousStyleString;
+    QString appendStyle;
 
     while (!htmlReader.atEnd()) {
         QXmlStreamReader::TokenType token = htmlReader.readNext();
         switch (token) {
         case QXmlStreamReader::StartElement:
         {
             newLine = false;
             if (htmlReader.name() == "br") {
                 qDebug() << "\tdoing br";
                 svgWriter.writeEndElement();
                 elementName = QStringRef(&p);
                 em = bodyEm;
+                appendStyle = previousStyleString;
             }
             else {
                 elementName = htmlReader.name();
                 em = "";
             }
 
             if (elementName == "body") {
                 qDebug() << "\tstart Element" << elementName;
                 svgWriter.writeStartElement("text");
+                appendStyle = QString();
             }
             else if (elementName == "p") {
                 // new line
                 qDebug() << "\t\tstart Element" << elementName;
                 svgWriter.writeStartElement("tspan");
                 newLine = true;
                 if (em.isEmpty()) {
                     em = bodyEm;
+                    appendStyle = QString();
                 }
                 lineCount++;
             }
             else if (elementName == "span") {
                 qDebug() << "\tstart Element" << elementName;
                 svgWriter.writeStartElement("tspan");
+                appendStyle = QString();
+            }
+            else if (elementName == "b" || elementName == "strong") {
+                qDebug() << "\tstart Element" << elementName;
+                svgWriter.writeStartElement("tspan");
+                appendStyle = "font-weight:700;";
+            }
+            else if (elementName == "i" || elementName == "em") {
+                qDebug() << "\tstart Element" << elementName;
+                svgWriter.writeStartElement("tspan");
+                appendStyle = "font-style:italic;";
+            }
+            else if (elementName == "u") {
+                qDebug() << "\tstart Element" << elementName;
+                svgWriter.writeStartElement("tspan");
+                appendStyle = "text-decoration:underline";
             }
 
             QXmlStreamAttributes attributes = htmlReader.attributes();
             if (attributes.hasAttribute("style")) {
                 QString filteredStyles;
                 QStringList svgStyles = QString("font-family font-size font-weight font-variant word-spacing text-decoration font-style font-size-adjust font-stretch direction").split(" ");
                 QStringList styles = attributes.value("style").toString().split(";");
                 for(int i=0; i<styles.size(); i++) {
                     QStringList style = QString(styles.at(i)).split(":");
 
                     if (svgStyles.contains(QString(style.at(0)).remove(" "))) {
                         filteredStyles.append(styles.at(i)+";");
                     }
                     if (QString(style.at(0)).contains("color") && !QString(style.at(0)).contains("-")) {
                         filteredStyles.append(" fill:"+style.at(1)+";");
                     }
 
                     if (QString(style.at(0)).contains("line-height")){
                         if (style.at(1).contains("%")) {
                             double percentage = QString(style.at(1)).remove("%").toDouble();
                             em = QString::number(percentage/100.0)+"em";
                         } else if(style.at(1).contains("em")) {
                             em = style.at(1);
                         } else if(style.at(1).contains("px")) {
                             em = style.at(1);
                         }
                         if (elementName == "body") {
                             bodyEm = em;
                         }
                     }
                 }
 
                 if (attributes.hasAttribute("align")) {
                     QString a = attributes.value("align").toString();
                     if (a.contains("center")) {
                         filteredStyles.append(" text-anchor:middle;");
                     } else if (a.contains("right")) {
                         filteredStyles.append(" text-anchor:end;");
                     } else {
                         filteredStyles.append(" text-anchor:start;");
                     }
                 }
+
+                filteredStyles.append(appendStyle);
+
                 if (!filteredStyles.isEmpty()) {
                     svgWriter.writeAttribute("style", filteredStyles);
+                    previousStyleString = filteredStyles;
                 }
 
 
             }
             if (newLine && lineCount > 1) {
                 qDebug() << "\t\tAdvancing to the next line";
                 svgWriter.writeAttribute("x", "0");
                 svgWriter.writeAttribute("dy", em);
             }
             break;
         }
         case QXmlStreamReader::EndElement:
         {
             if (htmlReader.name() == "br") break;
             if (elementName == "p" || elementName == "span" || elementName == "body") {
                 qDebug() << "\tEndElement" <<  htmlReader.name() << "(" << elementName << ")";
                 svgWriter.writeEndElement();
             }
             break;
         }
         case QXmlStreamReader::Characters:
         {
             if (elementName == "style") {
                 *styles = htmlReader.text().toString();
             }
             else {
                 if (!htmlReader.isWhitespace()) {
                     qDebug() << "\tCharacters:" << htmlReader.text();
                     svgWriter.writeCharacters(htmlReader.text().toString());
                 }
             }
             break;
         }
         default:
             ;
         }
     }
 
     if (htmlReader.hasError()) {
         d->errors << htmlReader.errorString();
         return false;
     }
     if (svgWriter.hasError()) {
         d->errors << i18n("Unknown error writing SVG text element");
         return false;
     }
 
     *svgText = QString::fromUtf8(svgBuffer.data());
     return true;
 }
 
 QStringList KoSvgTextShapeMarkupConverter::errors() const
 {
     return d->errors;
 }
 
 QStringList KoSvgTextShapeMarkupConverter::warnings() const
 {
     return d->warnings;
 }