
<p class="wp-block-paragraph">Armitage Farm hade högsta budet på tidigare Marcus Melander-tränade <strong>Kadena </strong>(e. Gimpanzee-Mission Brief), 1.09,0*/$209.917. Tävlingskarriären innehöll sex vinster på 20 starter och däribland seger i en division i Bluegrass Series ($73.800) och dubbla vinster i försök i Kentucky Commonwealth Series ($30.000).</p>



<p class="wp-block-paragraph">Som ettåring köpte Lennart Ågren och Jeff Snyder Kadena för 800.000 dollar på Lexington Selected Yearling Sale.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/10/snydermelanderstewartmfl231002adamstromstalltz-617x378.jpg" alt="" class="wp-image-504445"/><figcaption class="wp-element-caption">Glada miner efter köpet. Jeff Snyder till vänster om Marcus Melander köpte Kadena tillsammans med Lennart Ågren för 800.000 dollar som ettåring. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Modern <strong>Mission Brief</strong> (e. Muscle Hill-Southwind Serena), 1.08,6/$1.599.587, är också mor till <strong>Apex</strong> (e. Walner), 1.09,5*/$871.798, <strong>Vic Zelenskyy </strong>(e. Greenshoe), 1.08,5/$133.810, och <strong>Adirondack</strong> (e. Father Patrick), 1.09,7/$88.411.</p>



<h2 class="wp-block-heading">Fler dyringar</h2>



<p class="wp-block-paragraph">Armitage Farm tog också hand om den näst dyraste hästen. För fyraåriga <strong>Date Night Hanover </strong>(e. Chapter Seven-Don’t Wait Up), 1.08,0*/$936.876, var priset hela 985.000 dollar. Även hon har tränats av Marcus Melander.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/10/datenighthanoverddm251005adamstromstalltz-617x411.jpg" alt="" class="wp-image-776188"/><figcaption class="wp-element-caption">Date Night Hanover besegrar invändiga Warrawee Michelle. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Hon var inte heller någon billig historia som ettåring utan kostade 600.000 dollar. Date Night Hanover är undan <strong>Don’t Wait Up</strong> (e. Credit Winner), 1.18,7, som också är mor till tidigare Åke Svanstedt-tränade <strong>Delayed Hanover</strong> (e. Southwind Frank), 1.09,0/$853.610.</p>



<p class="wp-block-paragraph">Mormor <strong>Fabulous Kemp</strong> (e. Yankee Glide), 1.12,7/$36.062, är halvsyster med Hambletonian-vinnaren <strong>Trixton </strong>(e. Muscle Hill), 1.08,7*/$947.057. Fabulous Kemp är också mormor till Srf Stables Sprintermästare <strong>Crown </strong>(e. Muscle Hill), 1.09,0ak/6.447.188 kr.</p>



<h2 class="wp-block-heading">Fler blågula försäljningar</h2>



<p class="wp-block-paragraph">Tidigare Åke Svanstedt-tränade och delägda <strong>What A Bid Hanover (</strong>e. Muscle Hill-What A Knockout), 1.09,5*/$453.088, drog också iväg prismässigt. Indiana-stuteriet Kountry Lane betalade 650.000 dollar för henne.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/11/whatabidhanover23112024lisa-617x346.jpg" alt="" class="wp-image-662801"/><figcaption class="wp-element-caption">What A Bid Hanover och Åke Svanstedt. Foto: Lisa Photo</figcaption></figure>



<p class="wp-block-paragraph">Som ettåring ropades What A Bid Hanover in för 275.000 dollar och förutom Åke Svanstedt ägdes stoet tidigare av Lennart Ågren.</p>



<p class="wp-block-paragraph">What A Bid Hanover vann fem lopp under sin karriär och däribland Goldsmith Maid ($455.000) och Delvin Miller Memorial ($141.000).</p>



<p class="wp-block-paragraph">Modern <strong>What A Knockout </strong>(e. Donato Hanover), 1.09,9/$73.613, tävlade både för Åke Svanstedt och Marcus Melander. What A Knockout i samma syskonskara som Whataworkout (e. Muscle Hill), 1.09,9/$75.705.</p>



<h2 class="wp-block-heading">Kostade 200.000 dollar</h2>



<p class="wp-block-paragraph">Det blev en hel del svenska köp och allra mest kostade treåriga stoet <strong>Luna Lovegood</strong> (e. Gimpanzee-Southwind Venus), 1.09,5*/$422.010, och hon ropades in av agenten Robert Lindström för 200.000 dollar.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/10/lunalovegood18102024lisa-617x346.jpg" alt="" class="wp-image-649452"/><figcaption class="wp-element-caption">Luna Lovegood vid en tidigare seger för Dexter Dunn. Foto: Lisa Photo</figcaption></figure>



<p class="wp-block-paragraph">Luna Lovegood ägdes av familjen Melander (Holly Lane Stud East) och har startat 16 gånger (6-1-1) för Marcus Melander. Som tvååring tog hon hem Matron Stakes ($116.100), tre försök i Kentucky Championship Series ($80.000) på Red Mile och ett försök i Breeders Crown ($25.000). I år har hon tagit sin enda seger i ett försök i Kentucky Championship Series ($80.000).</p>



<p class="wp-block-paragraph">Luna Lovegood är undan <strong>Southwind Venus </strong>(e. Muscle Hill), 1.12,2/$80.357, vilken vann sex lopp på 37 starter i regi Marcus Melander.</p>



<p class="wp-block-paragraph">Southwind Venus har en startande avkomma sedan tidigare; Hambletonian Oaks-finalisten <strong>Miss I La</strong> (e. Walner), 1.08,9/$560.618. Själv kommer Southwind Venus från samma syskonskara som <strong>Tantalize Blue Chip</strong> (e. Devious Man), 1.11,6/$89.096.</p>



<p class="wp-block-paragraph">Totalt såldes det för rekordhöga 38,5 miljoner dollar på mixedauktionen och fjolårets siffror utklassades med 21,9 procent!</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<h2 class="wp-block-heading">Svenska köp:</h2>



<ul class="wp-block-list">
<li><strong>Luna Lovegood,</strong> 1.09,5/$422.010 (sto 3 år e. Gimpanzee-Southwind Venus)<br><em>– $200.000. <strong>Köpare:</strong> Robert Lindström i kom. </em></li>



<li><strong>Fashion Green</strong>, 1.08,4/$418.763 (valack 3 år e. Greenshoe-Fashion Athena) <br><em>– $130.000. <strong>Köpare:</strong> Johan Arneng i kom. </em></li>



<li><strong>Ms Prada</strong>, 1.09,1/$297.184 (sto 3 år e. Greenshoe-Asiago) <br><em>– $115.000. <strong>Köpare:</strong> Robert Lindström i kom.</em></li>



<li><strong>S I P</strong>, 1.08,7*/$518.851 (hingst 6 år e. Bar Hopping-Barbara Brooks) <br><em>– $100.000. <strong>Köpare: </strong>Johan Arneng i kom.</em></li>



<li><strong>Khaosan Road,</strong> 1.09,2/$493.056 (valack 5 år e. International Moni-Jewel In the Sand) <br><em>– $90.000. <strong>Köpare: </strong>Knutsson Trotting.</em></li>



<li><strong>Extra Gears</strong>, 1.12,0/$16.120 (sto 2 år e. Walner-Mazzarati) <br><em>– $75.000. <strong>Köpare:</strong> Robert Lindström i kom.</em></li>



<li><strong>Shelooksgoodngreen</strong>, 1.11,7/$17.589 (sto 2 år e. Greenshoe-Chapter Too) <br><em>– <strong>$50.000. Köpare:</strong> Jenny Melander i kom.</em></li>



<li><strong>Super Freak</strong>, 1.10,2/$54.570 (sto 3 år e. Muscle Hill-Moonlight Cocktail) <br><em>– $50.000. <strong>Köpare: </strong>Per Henriksen i kom.</em></li>



<li><strong>Malibu Cindy</strong>, 1.12,5/$5.800 (sto 2 år e. Chapter Seven-Malibu) <br><em>– $30.000. <strong>Köpare: </strong>Snogarps Gård.</em></li>



<li><strong>Charming Princess</strong>, 1.12,5/$12.235 (sto 3 år e. Greenshoe-Fashion Spooner) <br><em>– $27.000. <strong>Köpare: </strong>Robert Lindström i kom.</em></li>



<li><strong>Handle Station</strong>, 1.11,8/$16.628 (sto 2 år e. Captain Corey-Harness Am) <br><em>– $25.000.<strong> Köpare: </strong>Ecurie Diocles.</em></li>
</ul>



<p class="has-text-align-center wp-block-paragraph">***</p>



<h2 class="wp-block-heading">Tävlingshästar över 100.000 dollar:</h2>



<ul class="wp-block-list">
<li><strong>Kadena</strong>, 1.09,0/$209.917 (sto 3 år e. Gimpanzee-Mission Brief) <br><em>– $1.200.000 </em></li>



<li><strong>Date Night Hanover</strong>, 1.08,0/$936.876 (sto 4 år e. Chapter Seven-Don’t Wait Up) <br><em>– $985.000</em></li>



<li><strong>What A Bid Hanover,</strong> 1.09,5/$453.088 (sto 3 år e. Muscle Hill-What A Knockout) <em>– $650.000 </em></li>



<li><strong>My Bff Annee,</strong> 1.10,5/$17.300 (sto 3 år e. Tactical Landing-Avalicious)<br><em>– $350.000</em></li>



<li><strong>Security Protected</strong>, 1.08,5/$825.179 (hingst 4 år e. Father Patrick-Thatsnotmyname) <br><em>– $335.000</em></li>



<li><strong>Spicy Nice</strong>, 1.09,4/$268.850 (sto 3 år e. Tactical Landing-Maven) <br><em>– $300.000</em></li>



<li><strong>She’s A Rainbow,</strong> 1.13,0 (sto 2 år e. Muscle Hill-Ilia) <br><em>– $225.000</em></li>



<li><strong>Luna Lovegood,</strong> 1.09,5/$422.010 (sto 3 år e. Gimpanzee-Southwind Venus) <br><em>– $200.000</em></li>



<li><strong>Waldon Fashion</strong>, 1.11,1/$44.750 (sto 2 år e. Walner-Broadway Diamond)<br><em>– $200.000 </em></li>



<li><strong>Titian</strong>, 1.10,5/$41.660 (sto 3 år e. Muscle Hill-Big Barb) <br><em>– $160.000 </em></li>



<li><strong>Yannick G Kemp</strong>, 1.09,6/$261.014 (hingst 3 år e. Walner-Southwind Adele) <br><em>– $160.000 </em></li>



<li><strong>Jersey Slide</strong>, 1.09,7/$154.332 (sto 3 år e. Muscle Hill-Nantab) <br><em>– $155.000 </em></li>



<li><strong>Columba Hanover</strong>, 1.15,2 (sto 2 år e. Walner-Cedar Dove) <br><em>– $150.000 </em></li>



<li><strong>Global Sensation</strong>, 1.09,0/$204.825 (valack 3 år e. Chapter Seven-Fly Angel Fly) <br><em>– $150.000 </em></li>



<li><strong>Hangover</strong>, 1.09,0/$268.699 (sto 3 år e. Southwind Frank-Mezcal Morning) <br><em>– $150.000 </em></li>



<li><strong>Santa Caterina</strong>, 1.10,6/$54.350 (sto 3 år e. Walner-Treviso) <br><em>– $150.000 </em></li>



<li><strong>The Ice Princess,</strong> 1.11,6/$7.500 (sto 2 år e. Walner-The Ice Countess) <br><em>– $150.000 </em></li>



<li><strong>Southwind Cherry,</strong> 1.09,6/$277.590 (sto 5 år e. Muscle Hill-Counter Pointe) <br><em>– $147.000</em></li>



<li><strong>Jay Jay Cooler</strong>, 1.12,7/$7.305 (sto 2 år e. Tactical Landing-Cooler Schooner) <br>– $135.000</li>



<li><strong>Fashion Green</strong>, 1.08,4/$418.763 (valack 3 år e. Greenshoe-Fashion Athena)<br><em>– $130.000</em></li>



<li><strong>Torrisi</strong>, 1.09,1/$424.506 (sto 3 år e. Walner-Barn Girl) <br><em>– $120.000</em></li>



<li><strong>Ms Prada</strong>, 1.09,1/$297.184 (sto 3 år e. Greenshoe-Asiago) <br><em>– $115.000 </em></li>



<li><strong>She’s A Shoe In</strong>, 1.10,5/$303.613 (sto 3 år e. Greenshoe-Casaubon) <br><em>– $110.000 </em></li>



<li><strong>Bright Green</strong>, 1.09,6/$138.489 (sto 3 år e. Green Manalishi-Shine Bright) <br><em>– $100.000</em></li>



<li><strong>Foxy Amee</strong>, 1.09,7/$222.418 (sto 3 år e. Muscle Mass-Highland Foxytrotr) <br><em>– $100.000</em></li>



<li><strong>Googoo Goddess</strong>, 1.10,5/$27.853 (sto 3 år e. Googoo Gaagaa-Pure Ivory) <br><em>– $100.000</em></li>



<li><strong>Pelican Hanover,</strong> 1.10,1/$201.487 (sto 3 år e. Uncle Peter-Piney’s Schooner) <br><em>– $100.000</em></li>



<li><strong>S I P,</strong> 1.08,7*/$518.851 (hingst 6 år e. Bar Hopping-Barbara Brooks) <br><em>– $100.000</em></li>
</ul>
