diff --git a/expat/Changes b/expat/Changes
index 512364d..583c868 100644
--- a/expat/Changes
+++ b/expat/Changes
@@ -1,4 +1,4 @@
-Release 2.2.0 Sat June 18 2016
+Release 2.2.0 Tue June 21 2016
         Security fixes:
             #537  CVE-2016-0718 -- Fix crash on malformed input
                   CVE-2016-4472 -- Improve insufficient fix to CVE-2015-1283 /
diff --git a/expat/expat.spec b/expat/expat.spec
index f0f7d91..3000e9a 100644
--- a/expat/expat.spec
+++ b/expat/expat.spec
@@ -40,7 +40,7 @@
 /usr/share/man/man1/xmlwf.1.gz
 
 %changelog
-* Sat Jun 18 2016 Sebastian Pipping <sebastian@pipping.org>
+* Tue Jun 21 2016 Sebastian Pipping <sebastian@pipping.org>
 [Release 2.2.0-1]
 - Update for the 2.2.0 release.
 
diff --git a/htdocs/index.html b/htdocs/index.html
index 2cbbe85..e093312 100644
--- a/htdocs/index.html
+++ b/htdocs/index.html
@@ -60,7 +60,7 @@
 <h3 id="news">News</h3>
 
 <dl>
-  <dt><em>18 June 2016</em>,
+  <dt><em>21 June 2016</em>,
       Expat 2.2.0 released.
     </dt>
   <dd><p>Release 2.2.0 includes security &amp; other bug fixes.</p>
