
<p><strong>Wild Ticket </strong>(e. Chapter Seven-On the Wild Side) inledde karriären med en andraplats, men igår kunde hingsten avlägga maiden i andra starten i ett försök i New York Sire Stakes ($54.500) för hingstar och valacker.</p>



<p>Från spets vann Wild Ticket med två längder före Åke Svanstedt och Situationship (e. Chapter Seven) på 1.11,6/1.609 meter. Äger vinnaren gör Amg Stable, Kenneth Kjellgren, Heights Stable och Mantorp LLC.</p>



<p>Hingsten köptes i Lexington förra året och prislappen var 200.000 dollar. Ostartade modern <strong>On the Wild Side</strong> (e. Muscle Hill-Livininthefastlane) har sin första avkomma i Wild Ticket, medan hon själv är helsyster med<strong> Eazy Pass</strong>, 1.09,9/$169.860.</p>



<h2 class="wp-block-heading">Obesegrad i två starter</h2>



<p><strong>Date Night Hanover </strong>(e. Chapter Seven-Don’t Wait Up) följde upp debutsegern i New York Sire Stakes och tog hem sitt andra försök i löpningsserien ($36.600) igår. Via tredje inner och dödens kunde stoet gå undan med en längd för Brian Sears på 1.12,1.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/07/datenighthanover071623r11-617x411.jpg" alt="" class="wp-image-471766"/><figcaption class="wp-element-caption">Date Night Hanover. Foto: Fred J Brown Jr</figcaption></figure>



<p>600.000 dollar var priset för Date Night Hanover på Harrisburg-auktionen förra året. Hon är undan <strong>Don’t Wait Up</strong> (e. Credit Winner), vilken aldrig kom aldrig till start. Sitt rekord 1.18,7 travade hon i ett kvallopp för Trond Smedshammer.</p>



<p>Hon är mor till tidigare Åke Svanstedt-tränade <strong>Delayed Hanover (</strong>e. Southwind Frank), 1.09,0/$554.431. 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.</p>



<p>Tredje triumfen kom i Excelsior Series med stoet<strong> Dozen </strong>(e. Chapter Seven-Sequin) och hon spurtvann efter en resa i fjärde inner och andra utvändigt med hals för Scott Zeron på 1.12,7. Modern <strong>Sequin</strong> (e. Father Patrick), 1.11,5/$28.700, tränades av Nancy Takter och vann två lopp på sju starter.</p>



<h2 class="wp-block-heading">Andra segern</h2>



<p>Jenny Melanders <strong>Nottingham </strong>(e. E L Titan-Lady Marian) tog sin andra seger i tredje starten när valacken avgjorde med en dryg längd mot Nancy Takter-tränade Bargain (e. Chapter Seven) med en dryg längd på 1.12,0 för Marcus Miller.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/07/nottinghamfredjbrownjr-617x411.jpg" alt="" class="wp-image-471767"/><figcaption class="wp-element-caption">Nottingham. Foto: Fred J Brown Jr</figcaption></figure>



<p>Nottingham köptes i Harrisburg i höstas för 42.000 dollar. Modern <strong>Lady Marian</strong> (e. Self Possessed-Emotional Rescue), 1.12,1/$41.126, har sin främsta avkomma i <strong>Possessed Fashion</strong> (e. Donato Hanover), 1.09,5/$639.144, vilken vann 22 lopp på 152 starter.</p>



<h2 class="wp-block-heading">Dubbbel till Engblom</h2>



<p>Per Engbloms <strong>Karolina Solveig</strong> (e. Crazy Wow-La Tapatia) debutvann ett försök i Excelsior Series och utklassade sina motståndare med närmare fyra längder över målrakan för Joe Bongiorno. Vinnartiden skrevs till 1.13,7.</p>



<p>Stoet kostade 12.000 dollar på Goshen Yearling Sale ifjol. Hennes mor<strong> La Tapatia</strong> (e. Cumin), 1.12,5/$53.565, har också lämnat Credit Winner-sönerna <strong>Tober </strong>($879.067) och <strong>Bjanthony</strong> ($373.777).</p>



<p>Per Engbloms<strong> Eurobond</strong> (e. Love You-True Diva) spetsvann för David Miller i Chester igår med 2,5 längder på 1.10,1. Den åttaårige hingstens seger var värd 6.500 dollar.</p>



<p>På Tioga Downs hölls ytterligare försök i New York Sire Stakes. Stoet <strong>R Melina</strong> (e. Chapter Seven-Goodtogo Hanover) vann med 1,5 längder från spets för Tyler Buter på 1.12,5. Det var andra segern i tredje starten.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/07/rmelina07623r05-617x411.jpg" alt="" class="wp-image-471768"/><figcaption class="wp-element-caption">R Melina vid segern igår. Foto: Fred J Brown Jr</figcaption></figure>



<p>Prislappen för henne i Lexington var 110.000 dollar. Hon är undan <strong>Goodtogo Hanover</strong> (e. Explosive Matter), 1.10,7/$315.075, och hennes första avkomma. Själv är modern halvsyster med <strong>Stop Resistin</strong> ($127.058).</p>



<p>För <strong>Sister Mary Maude </strong>(e. Crazy Wow-Perfect Mass) var det tredje raka försöksvinsten i New York Sire Stakes och Joe Bongiorno vann med 2,5 längder från spets på 1.12,5.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/07/sistermarymaude071623r07-617x411.jpg" alt="" class="wp-image-471769"/><figcaption class="wp-element-caption">Sister Mary Maude. Foto: Fred J Brown Jr</figcaption></figure>



<p>Sister Mary Maude såldes förra hösten på Goshen Yearling Sale för 31.000 dollar. Hennes mor <strong>Perfect Mass</strong> (e. Muscle Mass), 1.11,6/$45.342, tävlade en period under Per Henriksens beskydd. Sister Mary Maude är hennes andra avkomma, medan hennes förstfödde – treårige <strong>Pontificate</strong> (e. Conway Hall) – är ostartad.</p>



<p>Mormor <strong>Perfect Prelude </strong>(e. Cantab Hall), 1.12,2/$82.816, vann försök i Pennsylvania Sire Stakes ($38.272) för Trond Smedshammer. I aveln har hon lämnat Elitloppsstartande <strong>Perfetto</strong> ($792.321), <strong>Modern Mass</strong> ($191.707), <strong>Seawind Pascale</strong> ($154.150) och<strong> Passarino </strong>($119.049).</p>



<h2 class="wp-block-heading">Snabbast på 1.10,9</h2>



<p>Fjärde försöksomgången i Ohio Sire Stakes ($55.000) för treåriga ston avgjordes på Northfield Park. Från ledningen vann <strong>Rose Run Yanae</strong> (e. Triumphant Caviar-Stonebridge Dancer) och Chris Page med närmare fyra längder på 1.10,9.</p>



<p>Rose Run Yolandas mor <strong>Rose Run Keepsake</strong> (e. Armbro Laser), 1.09,7*/$437.810, är helsyster med <strong>Rose Run Limo </strong>($190.474). Rose Run Yanae ingår i sin tur i samma syskonskara som <strong>Rose Run Sidney </strong>(e. Triumphant Caviar), 1.09,1/$597.703, och <strong>Rose Run Whitney</strong> (e. Uncle Peter), 1.10,3/$211.902.</p>



<p>Samma segerrecept hade <strong>Swinging Senorita</strong> (e. What the Hill-Lei Trevino) och Anthony MacDonald på 1.11,0 och vinstmarginalen skrevs till en kvarts längd.</p>



<p>Stoet såldes på Ohio Select Sale som ettåring för 20.000 dollar. Hon är en dotter till <strong>Lei Trevino</strong> (e. Ken Warkentin), 1.13,6<em>/</em>$49.856, vilken tidigare lämnat <strong>Trix Are For Kids </strong>(e. Trixton), 1.11,3/<em>$5</em>7.860.<em> </em>Själv är modern halvsyster med <strong>Stroke Play</strong> (e. Yankee Glide), 1.10,7/$1.284.688.</p>



<p>På Rideau Carleton Raceway bjöds det på försök i Ontario Sire Stakes Gold (C$100.400) för treåriga ston. Först ut var <strong>Mass Hysteria</strong> (e. Muscle Mass-Penetangore) och Trevor Henry. Från spets vann duon med närmare tre längder på 1.11,2.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2023/07/masshysteriabentenielsen.jpg" alt="" class="wp-image-471770"/><figcaption class="wp-element-caption">Mass Hysteria. Foto: Bente Nielsen</figcaption></figure>



<p>Ifjol vann stoet två försök i Ontario Sire Stakes Gold och slutade tvåa i finalen. Stoet tränas av Kyle Bossence och köptes för 23.000 dollar på London Selected-auktionen ifjol.</p>



<p>Mass Hysteria är undan <strong>Penetangore </strong>(e. Earl), 1.13,6/$83.130, och ingår i samma syskonskara som <strong>Arcanum</strong> (e. Archangel), 1.10,9/$102.596. Modern är i sin tur halvsyster med <strong>Pleasant Time</strong> (e. Super Pleasure), 1.14,0/$152.003, som startade 173 gånger (21 vinster) och bara travade en gång under 1.14,6.</p>



<p><strong>Climb the Pole</strong> (e. Kadabra-Legzy) flyttades upp som etta i det andra försöket där Righteous Resolve (e. Resolve) var först i mål. Stoet räknade in sin femte seger i tionde starten. Som ettåring köptes hon i Harrisburg för 110.000 dollar.</p>



<p>Modern <strong>Legzy</strong> (e. Amigo Hall)1.11,1/$277.660, har också lämnat <strong>Get Legs</strong> (e. Muscle Hill), 1.08,9/$205.000.</p>
