diff --git a/maven-plugin-api/src/main/java/org/apache/maven/plugin/AbstractMojo.java b/maven-plugin-api/src/main/java/org/apache/maven/plugin/AbstractMojo.java
index 8a168f7..352caeb 100644
--- a/maven-plugin-api/src/main/java/org/apache/maven/plugin/AbstractMojo.java
+++ b/maven-plugin-api/src/main/java/org/apache/maven/plugin/AbstractMojo.java
@@ -143,10 +143,6 @@
     /** Plugin container context */
     private Map pluginContext;
 
-    /**
-     * @deprecated Use SLF4J directly
-     */
-    @Deprecated
     @Override
     public void setLog(Log log) {
         this.log = log;
@@ -164,9 +160,7 @@
      * method directly whenever you need the logger, it is fast enough and needs no caching.
      *
      * @see org.apache.maven.plugin.Mojo#getLog()
-     * @deprecated Use SLF4J directly
      */
-    @Deprecated
     @Override
     public Log getLog() {
         if (log == null) {
diff --git a/maven-plugin-api/src/main/java/org/apache/maven/plugin/Mojo.java b/maven-plugin-api/src/main/java/org/apache/maven/plugin/Mojo.java
index 94e601e..1e12dd6 100644
--- a/maven-plugin-api/src/main/java/org/apache/maven/plugin/Mojo.java
+++ b/maven-plugin-api/src/main/java/org/apache/maven/plugin/Mojo.java
@@ -51,9 +51,7 @@
      *
      * @param log a new logger
      *
-     * @deprecated Use SLF4J directly
      */
-    @Deprecated
     void setLog(Log log);
 
     /**
@@ -61,8 +59,6 @@
      *
      * @return a log4j-like logger object which allows plugins to create messages at levels of <code>"debug"</code>,
      * <code>"info"</code>, <code>"warn"</code>, and <code>"error"</code>.
-     * @deprecated Use SLF4J directly
      */
-    @Deprecated
     Log getLog();
 }
diff --git a/maven-plugin-api/src/main/java/org/apache/maven/plugin/logging/Log.java b/maven-plugin-api/src/main/java/org/apache/maven/plugin/logging/Log.java
index 6336cc8..f28a3af 100644
--- a/maven-plugin-api/src/main/java/org/apache/maven/plugin/logging/Log.java
+++ b/maven-plugin-api/src/main/java/org/apache/maven/plugin/logging/Log.java
@@ -27,9 +27,7 @@
  * rather than formatting first by calling <code>toString()</code>.
  *
  *
- * @deprecated Use SLF4J directly
  */
-@Deprecated
 public interface Log {
     /**
      * @return true if the <b>debug</b> error level is enabled
diff --git a/maven-plugin-api/src/main/java/org/apache/maven/plugin/logging/SystemStreamLog.java b/maven-plugin-api/src/main/java/org/apache/maven/plugin/logging/SystemStreamLog.java
index b31f384..e42b663 100644
--- a/maven-plugin-api/src/main/java/org/apache/maven/plugin/logging/SystemStreamLog.java
+++ b/maven-plugin-api/src/main/java/org/apache/maven/plugin/logging/SystemStreamLog.java
@@ -25,9 +25,7 @@
  * Logger with "standard" output and error output stream.
  *
  *
- * @deprecated Use SLF4J directly
  */
-@Deprecated
 public class SystemStreamLog implements Log {
     /**
      * @see org.apache.maven.plugin.logging.Log#debug(java.lang.CharSequence)
