
<p>Från ledningen höll <strong>Tony Adams</strong> (e. Muscle Hill-Dreamgirl Hornline) undan med huvud för Nancy Takters Carrera Hanover (e. Bar Hopping) på 1.12,2/1.609 meter. Tony Adams är både uppfödd och ägd av Stall Arsenal i Glimåkra och debuterade med seger igår.</p>



<p>Modern <strong>Dreamgirl Hornline</strong> (e. Ready Cash), 1.13,9am/259.631 kr, har sin andra avkomma i Tony Adams. Själv ingår hon i samma syskonskara som bland andra <strong>Åjo Hornline</strong> (730.650 kr) och <strong>Xray Hornline</strong> (427.227 kr).</p>



<h2 class="wp-block-heading">Balazsi-uppfödning  debutvann</h2>



<p><strong>Winter Soldier</strong> (e. Face Time Bourbon-Jumalay Mass) debutvann den andra divisionen för hingstar och valackerna för Andrew McCarthy med en längd på 1.10,7. Tvåa var Åke Svanstedt med svenskfödde Flying Kronos (e. Face Time Bourbon) på 1.10,9.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/07/wintersoldier2872023lisa-617x346.jpg" alt="" class="wp-image-476684"/><figcaption class="wp-element-caption">Winter Soldier vinner för Andrew McCarthy. Foto: Lisa Photo</figcaption></figure>



<p>Winter Soldier är uppfödd av Stefan ”Order By Stable” Balazsi och såldes för 140.000 dollar på Lexington Selected Yearling Sale. Modern <strong>Jumalay Mass</strong> (e. Muscle Mass), 1.12,1/$48.930, har sin första avkomma i Winter Soldier.</p>



<h2 class="wp-block-heading">Andra segern i karriären</h2>



<p><strong>T C I</strong> (e. Cantab Hall-Nicole’s Promise) och David Miller vann med två längder från spets på 1.11,3 före Nancy Takter-tränade Magic Hill (e. Muscle Hill), som noterade 1.11,6. Det var andra segern och tidigare har han vunnit försök i Pennsylvania Sire Stakes ($25.270).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/07/tci2872023lisa-617x346.jpg" alt="" class="wp-image-476685"/><figcaption class="wp-element-caption">T C I och David Miller. Foto: Lisa Photo</figcaption></figure>



<p>Priset för T C I i Harrisburg var 150.000 dollar. Han är undan <strong>Nicole’s Promise</strong> (e. Dream Vacation), 1.10,6*/$327.255, vilken varit en hit i avelsboxen med avkommor som <strong>Livininthefastlane</strong> ($460.481), <strong>Global Pandemic </strong>($212.174), <strong>Jula Magician </strong>($170.642), <strong>Piranha Fury</strong> ($144.358), <strong>Promise Delivered</strong> ($129.240) och <strong>Mistresswithmuscle</strong> ($104.097).</p>



<h2 class="wp-block-heading">Takter-sto obesegrad i två starter</h2>



<p>Toppstammade <strong>Cheval Rapide</strong> (e. Father Patrick-Shake It Cerry) och Yannick Gingras räknade in sin andra raka försöksvinst i Kindergarten Series och är obesegrad efter två starter. Nancy Takters sto vann med en halv längd från spets på 1.11,1.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/07/chevalrapidejtpr230728adamstromstalltz-617x400.jpg" alt="" class="wp-image-476693"/><figcaption class="wp-element-caption">Christina och Jimmy Takter efter Cheval Rapides seger. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>Modern <strong>Shake It Cerry </strong>(e. Donato Hanover-Solveig), 1.08,2/$2.863.184, har två avkommor sedan tidigare; <strong>Mon Cheval </strong>(e. Father Patrick), 1.08,9/$404.100, och <strong>Hill of Fame</strong> (e. Muscle Hill), 1.11,6/$8.100, som startade två gånger, tog en seger och ett andrapris. </p>



<p>Shake It Cerry blev det vinstrikaste stoet i USA både som två- och treåring och de två åren fick hon också mottaga utmärkelsen ”Årets Sto”. Som treåring utsågs hon också till ”Årets Travare”.</p>



<p>Scott Zeron vann den andra divisionen bakom <strong>Internationalmodel</strong> (e. International Moni-Flying Glider) via tredje inner och dödens med hals på 1.11,7. Precis som Cheval Rapide är hon obesegrad i två starter och inledde också karriären med seger i ett försök i Kindergarten Series.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/07/internationalmodel2872023lisa-617x346.jpg" alt="" class="wp-image-476686"/><figcaption class="wp-element-caption">Internationalmodel och Scott Zeron. Foto: Lisa Photo</figcaption></figure>



<p>Internationalmodel såldes i Lexington för 55.000 dollar. Hennes ostartade mor <strong>Flying Glider </strong>(e. Cantab Hall) ingår i samma syskonskara som <strong>Sunset Glider</strong> ($250.836) och <strong>Highest Peak</strong> ($148.270).</p>



<h2 class="wp-block-heading">Vann med tre längder</h2>



<p>Dubbla försök i New York Sire Stakes ($87.000) för treåriga ston hölls på Saratoga Raceway i natt. <strong>Royal Filly</strong> (e. Chapter Seven-Swinging Royalty) gjorde sitt jobb från spets för Tyler Buter och vann med drygt tre längder på 1.11,7. Tidigare i år har stoet vunnit en division av Empire Breeders Classic ($104.371) och ett försök i New York Sire Stakes ($61.400).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/07/royalfillyjessicahallettphoto-617x411.jpg" alt="" class="wp-image-476687"/><figcaption class="wp-element-caption">Royal Filly vid gårdagens vinst. Foto: Jessica Hallett Photo</figcaption></figure>



<p>Modern <strong>Swinging Royalty</strong> (e. RC Royalty), 1.10,9/$255.880, har tidigare lämnat <strong>Ahundreddollarbill</strong> (e. Chapter Seven), 1.08,6*/$936.230, och <strong>Slay </strong>(e. Chapter Seven), 1.09,0/$836.910. Swinging Royalty ingår i samma syskonskara som <strong>Cash Infusion </strong>($261.592), <strong>Cash Hit</strong> ($221.191) och <strong>Lights Down Low</strong> ($100.857).</p>



<p>Tidigare Marcus Melander-tränade <strong>Canterbury Hanover</strong> (e. Chapter Seven-Charmed Life) vann det andra försöket efter en utvändig resa för sin tränare Jeff Gregory med nos på 1.13,0. Tidigare i år har stoet vunnit försök i Excelsior Series ($20.000).</p>



<p>Stoet kostade 110.000 dollar som ettåring och hon är första avkomman undan kanadensiska toppstoet <strong>Charmed Life</strong> (e. Majestic Son), 1.08,9/$1.564.511, vilken vann 34 lopp på 151 starter. Mormor <strong>Christina M</strong> (e. Muscles Yankee), 1.12,6/$44.475, har också lämnat <strong>Apprentice M</strong> (e. Kadabra), 1.12,2/$191.750.</p>



<h2 class="wp-block-heading">Greenshoe-dotter starkast i spurten</h2>



<p>På Meadows hölls Arden Downs ($20.000) för tvååringar. Stona bjöd på två divisioner och Greenshoe-dottern <strong>Insider Trading</strong> (u. Topcat Hall) var snabbast och avgjorde i spurten med 1,5 längder på 1.12,6 för Anthony MacDonald.</p>



<p>Stoet kostade 42.000 dollar i Harrisburg och är undan <strong>Topcat Hall </strong>(e. Conway Hall), 1.13,0/$7.145, vilken har sina främsta avkommor i trion <strong>Jl Cruze</strong> ($1.873.503), <strong>Sheez Ona Cruze</strong> ($230.330) och <strong>Hill of A Colt</strong> ($141.530).</p>



<p><strong>Skyline Seashell</strong> (e. Father Patrick-Fate Smiled) spetsvann den andra divisionen för Mike Wilder med en längd på 1.13,0 och hon avlade maiden i sin femte start. Prislappen var också 42.000 dollar och Skyline Seashell såldes på Lexington Select Yearling Sale ifjol.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/07/skylineseashell2872023chrisgooden-617x347.jpg" alt="" class="wp-image-476688"/><figcaption class="wp-element-caption"><strong>Skyline Seashell</strong> och Mike Wilder. Foto: Chris Gooden</figcaption></figure>



<p>Modern <strong>Fate Smiled</strong> (e. Muscle Massive), 1.11,0/$158.119, har sin första avkomma i Skyline Seashell och själv är hon undan <strong>For A Dance</strong>r ($521.508) och halvsyster med <strong>For A Dreamer</strong> ($407.038).</p>



<h2 class="wp-block-heading">Försvann med 6,75 längder</h2>



<p>Hingstarna och valackerna tävlade i tre divisioner. Först ut var <strong>Honor Guard</strong> (e. Father Patrick-Honor Thy Daughter) och valacken försvann med 6,75 längder över målrakan. Segertiden skrevs till 1.13,7 och Dave Palone höll i tömmarna när Honor Guard räknade in sin första triumf i fjärde starten.</p>



<p>Han såldes på Lexington Select Yearling Sale för 30.000 dollar. Modern <strong>Honor Thy Daughter </strong>(e. Donato Hanover), 1.12,6*/$57.164, är också mor till <strong>Beautiful Game </strong>($302.406) och <strong>Special Honor</strong> ($301.147).</p>



<p><strong>Activation</strong> (e. Father Patrick-Repentance) och Anthony MacDonald vann den andra divisionen från spets med 2,5 längder på 1.13,6. Det var karriärens fjärde seger på fem starter och valacken har också en andraplats.</p>



<p>Prislappen var 27.000 dollar i Lexington och Activation är undan <strong>Repentance </strong>(e. Chapter Seven), 1.09,9/$278.854, och hennes första startande avkomma. Modern är i sin tur halvsyster med <strong>Altar </strong>($220.206).</p>



<p>Anthony MacDonald vann också bakom <strong>Memoryinmagination </strong>(e. Father Patrick-Fellowship of Two) från dödens med 3,5 längder på 1.13,0. För valacken var det första segern i tredje starten.</p>



<h2 class="wp-block-heading">Vilket möderne!</h2>



<p>Han såldes i Harrisburg för 77.000 dollar och är undan ostartade <strong>Fellowship of Two</strong> (e. Trixton) och hennes första avkomma. Hon är i sin tur en dotter till <strong>Solveig</strong> (e. Yankee Glide-Exquistie Amanda), 1.11,3/$820.719.</p>



<p>Solveig har lämnat en rad topptravare som <strong>Shake It Cerry </strong>(e. Donato Hanover), 1.08,2/$2.863.184, <strong>Uncle Lasse</strong> (e. Donato Hanover), 1.09,3ak*/9.149.027 kr, <strong>Solvato</strong> (e. Donato Hanover), 1.09,9ak/6.195.590 kr, <strong>Dontyouforgetit</strong> (e. Cantab Hall), 1.09,7/$598.049, <strong>Jimmy William</strong> (e. Cantab Hall), 1.10,2/$129.051, och <strong>Aunt Irene</strong> (e. Trixton-Solveig), 1.10,2/$124.988.</p>

Fokustema
Utblick USA
Läs senare
Svenskfödd tvååring i topp
Två svensktränade vinnare blev det i Kindergarten Series ($20.000) för tvååringar på Meadowlands i natt och en av dem var svenskfödde Tony Adams för Åke Svanstedt.
