
<p>Först ut var <strong>Oh Well </strong>(e. Muscle Hill-Fine Tuned Lady) och Tim Tetrick i ett försök för treåriga hingstar och valacker. Från spets höll han undan med huvud före Celebrity Bambino (e. Muscle Hill) och trea slutade Marcus Melanders Challenger (e. Muscle Hill).</p>



<p>Vinnartiden för Oh Well skrevs till 1.10,0/1.609 meter efter 1.06,7 sista 400 meterna. Lennart ”Srf Stable” Ågren-ägde Oh Well tog sin andra seger för säsongen – han har också sex andraplatser – efter tidigare vunnit en division av Stanley Dancer Memorial ($138.500) och nämnas ska förstås också andraplatsen i Hambletonian Stakes.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/09/ohwell192023lisa-617x346.jpg" alt="" class="wp-image-491376"/><figcaption class="wp-element-caption">Oh Well (mitten) och Tim Tetrick håller undan till seger. Foto: Lisa Photo</figcaption></figure>



<p>Ifjol blev det fyra vinster och den största kom i miljondollarloppet Mohawk Million (C$1.000.000) på Mohawk Raceway. Oh Well finalvann också New Jersey Classic ($275.000) och New Jersey Sire Stakes ($240.000) plus att han slutade tvåa i Peter Haughton Memorial bakom Kilmister.</p>



<p>Lennart Ågren betalade 530.000 dollar för Oh Well i Harrisburg som ettåring och han är moderns första avkomma. <strong>Fine Tuned Lady</strong> (e. Cantab Hall) tog vinnarrekordet 1.09,8 och sprang in 643.987 dollar.</p>



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



<p><strong>Air Power </strong>(e. Muscle Hill-Beyond Blue) vann det andra försöket för treåriga hingstar och valacker för Mattias Melander. Via tredje inner och dödens avgjorde den Stefan ”Order By Stable” Balazsi-uppfödningen med 2,5 längder på 1.09,6 efter snabba 1.06,7 sista 400 meterna. Här var Åke Svanstedt trea med Up Your Deo (e. Walner) på 1.10,0.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/09/melandermattias211104adamstromstalltz-617x473.jpg" alt="" class="wp-image-360525"/><figcaption class="wp-element-caption">Mattias Melander. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>Air Power ägs av Amg Stable, Rick Wahlstedt, Kenneth Kjellgren och Height Stables och han galopperade bort sig som favorit i sitt försök i Hambletonian Stakes. Senaste segern togs i en final i New Jersey Sire Stakes ($240.000) i början av juni och då satt Andrew McCarthy i sulkyn.</p>



<p>Som ettåring köptes Air Power i Harrisburg för 105.000 dollar. Han är undan <strong>Beyond Blue </strong>(e. Cantab Hall), 1.13,9/$31.905, som startade nio gånger (2-2-3) under Ron Gurfeins vingar. Förutom Air Power har Beyond Blue lämnat <strong>Homen Dry</strong> (e. Credit Winner), 1.09,7/$579.370, och<strong> Seven Iron </strong>(e. Chapter Seven), 1.10,6/$375.545.</p>



<h2 class="wp-block-heading">Svanstedt etta och tvåa</h2>



<p>Åke Svanstedts seger i New Jersey Classic ($25.000) kom i ett försök för tvååriga ston. <strong>Sunkist Beauty</strong> (e. Six Pack-Orange Bi) avgjorde med en halv längd efter en resa i fjärde inner och dödens. Stoet avslutade sista 400 meterna på 1.07,1 och vinnartiden skrevs till 1.10,9 i ett lopp där Lucas Wallins Soiree Hanover (e. Walner) slutade trea på 1.11,2.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/09/sunkistbeauty192023lisa-617x346.jpg" alt="" class="wp-image-491377"/><figcaption class="wp-element-caption">Sunkist Beauty vinner för Åke Svanstedt. Foto: Lisa Photo</figcaption></figure>



<p>För Sunkist Beauty var det andra segern i karriären. Hon har också vunnit ett försök i New Jersey Sire Stakes ($30.000) och slutat tvåa i finalen efter Buy A Round.</p>



<p>Stoet ägs av Åke Svanstedt och Stall Kalmar och köptes in på Lexington Selected Yearling i höstas för 63.000 dollar. Hon är undan <strong>Orange Bigi</strong> (e. S.J.’s Caviar), 1.10,2/$363.440, som startade 214 gånger och vann 27 lopp. Mormor <strong>Emerald City</strong> (e. Donerail), 1.14,0/$566, hamnade i Italien och där blev hon också mor till <strong>Rachmaninov Bigi</strong> (e. Andover Hall), 1.14,3/€30.493, och <strong>Vlad Vik</strong> (e. Daguet Rapide), 1.14,1/€26.070.</p>



<p>En andraplats blev det för Åke Svanstedt och Warrawee Michelle (e. Chapter Seven) i det andra försöket för de tvååriga stona från spets. Brian Sears vann bakom Trond Smedshammers debutant <strong>Chaparmbro</strong> (e. Chapter Seven-Armbro Deja Vu) från rygg ledaren med huvud på 1.11,0.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/09/chaparmbro192023lisa-617x346.jpg" alt="" class="wp-image-491378"/><figcaption class="wp-element-caption">Utvändiga Charparmbro vinner för Brian Sears. Foto: Lisa Photo</figcaption></figure>



<p>Stoet kostade hela 260.000 dollar i Harrisburg förra året. Hon är undan <strong>Armbro Deja Vu</strong> (e. Donerail), 1.10,9/$21.079, vilken varit en riktig kassapjäs i avelsboxen med avkommor som <strong>Dejarmbro</strong> ($1.135.123), <strong>Shared Past </strong>($416.606), <strong>Hello Tomorrow </strong>($171.344), <strong>Borrow and Spend</strong> ($159.370), <strong>Personal Paradise</strong> ($116.629) och <strong>Open Access</strong> ($113.438).</p>



<p>Tredje försöket för de tvååriga stona togs hem av Noel Daley-tränade <strong>Buy A Round </strong>(e. Walner-On Your Tab) och Andrew McCarthy. Via fjärde inner spurtvann hon på 1.11,2. Stoet har tidigare vunnit försök och final i New Jersey Sire Stakes ($240.000).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/08/wb080523r13buyaround-617x346.jpg" alt="" class="wp-image-479548"/><figcaption class="wp-element-caption">Buy A Round vid en tidigare vinst för Andrew McCarthy. Foto: Lisa Photo</figcaption></figure>



<p>Buy A Round var utbjuden till försäljning på Lexington Selected Yearling Sale, men ropades tillbaka för 85.000 dollar. Modern <strong>On Your Tab</strong> (e. Cantab Hall), 1.16,2/$640, gjorde bara två starter med en fjärdeplats som främsta merit. Hon har en avkomma sedan tidigare; <strong>On the House </strong>(e. Chapter Seven), 1.09,9/$76.329, vilken tränas av Åke Svanstedt och har vunnit tre lopp på 13 starter.</p>



<p>On Your Tab ingår i en framgångsrik syskonskara och nämnas kan<strong> Smoke and Mirrors</strong> ($370.219), <strong>In the Mean Time</strong> ($233.554), <strong>Choir Robe </strong>($184.230), <strong>Tight Pants</strong> ($172.680) och <strong>Church Sout</strong> ($130.789).</p>



<h2 class="wp-block-heading">Vinst från rygg ledaren</h2>



<p>Anette Lorentzon-tränade <strong>Quick Stop</strong> (e. Tactical Landing-Falls For You) vann ett försök i New Jersey Classic ($25.000) för treåriga ston efter en resa i rygg på ledaren för Tim Tetrick på 1.11,2. Hon besegrade Åke Svanstedt och Cyberspace (e. Walner), vilka var slagna med en dryg längd från spets.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/07/quickstop2262022lisa-1-617x346.jpg" alt="" class="wp-image-322108"/><figcaption class="wp-element-caption">Quick Stop vid en tidigare vinst. Foto: Lisa Photo</figcaption></figure>



<p>Quick Stop står med tre segrar på åtta starter i år. Tidigare har hon vunnit en division av Delvin Miller Memorial ($105.250) respektive W.N. Reynolds Memorial ($37.400) på Meadowlands.</p>



<p>Stoet, som ägs av ACL Stuteri och Anette Lorentzon, köptes i Harrisburg som ettåring för 72.000 dollar. Hon är en dotter till Trond Smedshammers stjärna <strong>Falls For You</strong> (e. Yankee Glide), 1.09,7/$1,326.357, som bland annat tog hem Goldsmith Maid, Kentucky Futurity Filly och Armbro Flight Stakes. Falls For You har också lämnat <strong>Mazzarati</strong> ($332.465), <strong>Toccoa Falls</strong> ($298.352) och Jörgen Westholm-tränade <strong>Remarkable Feet</strong> (e. Andover Hall), 1.11,3ak/2.361.654 kr.</p>



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



<p>Det hölls också två försök i New Jersey Classic ($25.000) för tvååriga hingstar och valacker. Via tredje inner spurtvann <strong>Mr Grant</strong> (e. Tactical Landing-Flos Conch Shack) med två längder på 1.11,8 för Brian Sears. Åke Svanstedt-tränade Tony Adam (e. Muscle Hill) slutade tvåa för Yannick Gingras på 1.12,1.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/09/mrgrant192023lisa-617x346.jpg" alt="" class="wp-image-491379"/><figcaption class="wp-element-caption">Mr Grant och Brian Sears. Foto: Lisa Photo</figcaption></figure>



<p>Tre segrar på fem starter har Mr Grant, vilken såldes för 16.000 dollar i Harrisburg. Doug R Ackermans valack är undan <strong>Flos Conch Shack</strong> (e. Father Patrick), 1.12,2/$31.150, och hennes första avkomma. Mödernet går tillbaka till <strong>Ultimate Cameron</strong> (e. Yankee Glide), 1.10,6/$809.899, vilken i sin tur är en dotter till<strong> Cameron Hall </strong>(e. Garland Lobell), 1.10,7*/$2.138.787.</p>



<p>Det andra försöket gick till Noel Daley-tränade <strong>Sig Sauer </strong>(e. Muscle Hill-Sigilwig) och Andrew McCarthy, vilka avgjorde med hals i spurten på 1.12,0 efter snabba 1.06,7 sista 400 meterna. Åke Svanstedt var tvåa med Southwind Metric (e. Walner) på samma tid, medan Lucas Wallin-tränade Mosquito (e. Muscle Hill) noterade 1.12,1 som trea.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/09/sigsauer192023lisa-617x346.jpg" alt="" class="wp-image-491380"/><figcaption class="wp-element-caption">Sig Sauer (6) håller undan vill vinst. Foto: Lisa Photo</figcaption></figure>



<p>Sig Sauer är obesegrad i tre starter och har tidigare vunnit försök och final i New Jersey Sire Stakes ($240.000).</p>



<p>Hela 200.000 dollar var priset för hingsten på Lexington Selected Yearling Sale. Modern <strong>Sigilwig</strong> (e. Donato Hanover), 1.13,0/$32.615, har sin första avkomma i Sig Sauer. Hon är i sin tur undan <strong>Pine Yankee</strong> (e. Yankee Glide), 1.11,3/$99.247, vilken också lämnat<strong> Love Muffin</strong> (e. Andover Hall), 1.10,1/$183.614, och <strong>Big Barb</strong> (e. Andover Hall), 1.12,2/$66.573. Den senare är mor till Stefan Balazsi-uppfödde<strong> Back of the Neck</strong> (e. Ready Cash), 1.08,8/$1.552.773.</p>



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



<p>Två försök i New York Sire Stakes ($51.500) för tvååriga ston avgjordes på 800-metersbanan Batavia Downs. <strong>Sadbirdstillsing </strong>(e. Chapter Seven-Fade Into You) räknade in sin andra raka försöksvinst och från rygg ledaren avgjorde Tony Alagnas sto med en dryg längd för Tyler Buter på 1.14,4.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/08/sadbirdstillsingscaled-617x503.jpg" alt="" class="wp-image-488450"/><figcaption class="wp-element-caption">Utvändiga Sadbirdstillsing och Tyler Buter vid en tidigare seger. Foto: Fotowon Photo</figcaption></figure>



<p>Prislappen för stoet var 190.000 dollar i Lexington förra året. Hon är undan <strong>Fade Into You</strong> (e. Cantab Hall), 1.09,1/$215.628, och moderns första avkomma. Fade Into You ingår i sin tur i samma syskonskara som <strong>Fifty Ways</strong> (e. Donato Hanover), 1.10,6/$206.235.</p>



<p>Jim Morrill Jr. guidade den andra vinnaren och från spets vann <strong>Erin</strong> (e. E L Titan-Blurred) med drygt tre längder på 1.15,0. Dan Daley tränar stoet och hon avlade maiden i sin sjätte start efter tidigare varit två och trea (två gånger) i försök i New York Sire Stakes.</p>



<p>Som ettåring kostade Erin 26.000 dollar i Lexington. Hon är undan <strong>Blurred</strong> (e. Chapter Seven), 1.14,2, som startade sju gånger utan att tjäna en endaste dollar. Erin är hennes tredje och första startande avkomma. Blurred är undan Trond Smedshammers Breeders Crown-vinnare <strong>Blur </strong>(e. Muscles Yankee), 1.10,7/$1.087.000, vilken också lämnat <strong>Bluto</strong> ($336.799),<strong> Martino</strong> ($223.335), <strong>Bluff </strong>($172.048), Buff ($171.760) och <strong>Insured Am</strong> ($108.378).</p>



<h2 class="wp-block-heading">Debutseger för Wallin-tvååring</h2>



<p>Apropå Bluff så hade hon en segrande avkomma i Chester igår. Lucas Wallin-tränade <strong>Life On the Bluf</strong> (e. Walner) avgjorde med en längd i spurten för Tim Tetrick i sin debut. Den tvåårige hingsten kom hem på 1.13,1. Lucas Wallin deläger och förstapriset uppgick till 5.850 dollar.</p>



<p>Life On the Bluf köptes för 155.000 dollar i Harrisburg och modern <strong>Bluff</strong> (e. Donato Hanover), 1.10,1/$172.048, är också mamma till trion <strong>Bluffinner</strong> ($268.593), <strong>Summit In Sight</strong> ($128.182) och <strong>Activist</strong> ($116.926).</p>
