diff --git a/Logo.html b/Logo.html
index dddac38..ea7690c 100755
--- a/Logo.html
+++ b/Logo.html
@@ -11,6 +11,18 @@
 <a href="http://en.wikipedia.org/wiki/Dragon_Book_(computer_science)">compiler
 books</a> going back to 1977 which featured dragons on the cover.</p>
 
+<p><img src="img/LLVMWyvernSmall.png" alt="Small Wyvern logo" width="1100" height="686"></p>
+
+You can also download a larger version of <a href="img/LLVMWyvernBig.png">this image</a> here.
+
+
+<div class="www_subsection">Older Dragon Logo</div>
+
+<p>LLVM used an older dragon logo for many years.  This version is endearing
+for many reasons, including an unproven theory that it has its head upside 
+down (and an anonymous Australian takes the controversial view that its body 
+is actually upside down)!</p>
+
 <p>Here is the image in a couple of sizes:</p>
 
 <p><img src="img/DragonSmall.png" alt="small dragon logo" width="136" 
@@ -19,7 +31,7 @@
 <p><img src="img/DragonMedium.png" alg="medium dragon logo" width="400"
 height="400"></p>
 
-<div class="www_subsection">Derivative Versions</div>
+<div class="www_subsection">Derivative Versions of the Older Logo</div>
 
 <div class="www_text">
 
diff --git a/img/LLVMWyvernBig.png b/img/LLVMWyvernBig.png
new file mode 100644
index 0000000..3dd4c7a
--- /dev/null
+++ b/img/LLVMWyvernBig.png
Binary files differ
diff --git a/img/LLVMWyvernSmall.png b/img/LLVMWyvernSmall.png
new file mode 100644
index 0000000..f474d67
--- /dev/null
+++ b/img/LLVMWyvernSmall.png
Binary files differ
