<p>Snabbaste vinnaren visade Åke Svanstedt upp i ett försök i New Jersey Sire Stakes ($25.000) för treåriga hingstar och valacker när Yannick Gingras guidade <strong>Mon Amour</strong> (e. Muscle Hill Hill-Mind Meld) till första årssegern efter ha varit tvåa i årsdebuten bakom Cuatro de Julio.</p>
<figure id="attachment_29338" aria-describedby="caption-attachment-29338" style="width: 350px" class="wp-caption alignright"><a href="https://sulkysport.se/wp-content/uploads/2018/08/akesvanstedtsulky.jpg"><img class="size-sulky-liten2 wp-image-29338" src="https://sulkysport.se/wp-content/uploads/2018/08/akesvanstedtsulky-350x187.jpg" alt="" width="350" height="187" /></a><figcaption id="caption-attachment-29338" class="wp-caption-text">Åke Svanstedt. Foto Jeannie Karlsson/Sulkysport</figcaption></figure>
<p>Igår fick han revansch på den sistnämnde sedan Mon Amour vunnit med närmare tre längder på 1.09,6/1.609 meter från spets, medan Cuatro de Julio (e. Trixton) noterade 1.10,0 som tvåa. Åke Svanstedt satt själv bakom Red Redemption (e. Muscle Hill) och var femma på 1.10,2.</p>
<p>Förra året vann Mon Amour två försök i New Jersey Sire Stakes ($25.000) och då var han i träning hos Per Engblom.</p>
<p>Mon Amour kostade 180.000 dollar i Lexington och han är andra avkomman undan <strong>Mind Meld</strong> (e. Donato Hanover-Myth), 1.14,1*/$3.250, som bara startade en gång och vann.</p>
<p>Mormor Myth (e. Lindy Lane), TT 1.13,1/$2.875, har varit en fullträff i aveln med avkommor som avelshingsten Mythical Lindy ($640.123), Mythical Hall ($587.320), Scirocco Insosmart ($131.195), och Valbruna ($116.217).</p>
<h2>Höll undan med nos</h2>
<p>Nancy Takters <strong>Locatelli</strong> (e. Muscle Hill-Girlie Tough) vann också ett försök i New Jersey Sire Stakes och han höll undan med nos från spets för Yannick Gingras på 1.10,1.</p>
<figure id="attachment_167022" aria-describedby="caption-attachment-167022" style="width: 617px" class="wp-caption aligncenter"><a href="https://sulkysport.se/wp-content/uploads/2021/05/locatelliinvsonofamistery2152021lisa.jpg"><img class="size-sulky-mellan2 wp-image-167022" src="https://sulkysport.se/wp-content/uploads/2021/05/locatelliinvsonofamistery2152021lisa-617x346.jpg" alt="" width="617" height="346" /></a><figcaption id="caption-attachment-167022" class="wp-caption-text">Invändige Locatelli håller undan till vinst för Sonofamistery. Foto: Lisa Photo</figcaption></figure>
<p>Knappt slagen var Marcus Melanders Sonofamistery (e. Muscle Hill) på samma tid som vinnaren efter ha avslutat sista 400 meterna på 1.07,6 för Brian Sears. Fyra slutade Åke Svanstedts Calle Palema (e. Muscle Hill) på 1.10,3 för Scott Zeron.</p>
<p>Hela 170.000 dollar kostade Locatelli i Harrisburg som ettåring. Locatelli är undan <strong>Girlie Tough</strong> (e. Conway Hall), 1.12,0/$70.887, som också är mor till <strong>Gatka Hanover</strong> ($262.685), <strong>Heaven’s Door</strong> (2.284.621 kr), <strong>Grimmie Hanover</strong> ($190.608) och <strong>High Heels</strong> ($111.475).</p>
<h2>Stark avslutning</h2>
<p>Lucas Wallins seger kom med <strong>Material Girl</strong> (e. Muscle Hill-Lilu Hanover) i ett försök i New Jersey Sire Stakes ($25.000) för treåriga ston och hon kunde avgöra med hals efter vassa 1.07,6 sista quartern för Tim Tetrick. Trea var Åke Svanstedt bakom Presto (e. Trixton) på 1.11,1 och femma Jonas Czernysons Chablis (e. Muscle Hill) på 1.11,6.</p>
<figure id="attachment_167023" aria-describedby="caption-attachment-167023" style="width: 617px" class="wp-caption aligncenter"><a href="https://sulkysport.se/wp-content/uploads/2021/05/materialgirl2152021lisa.jpg"><img class="size-sulky-mellan2 wp-image-167023" src="https://sulkysport.se/wp-content/uploads/2021/05/materialgirl2152021lisa-617x346.jpg" alt="" width="617" height="346" /></a><figcaption id="caption-attachment-167023" class="wp-caption-text">Material Girl vinner för Tim Tetrick. Foto: Lisa Photo</figcaption></figure>
<p>För Material Girl var det andra segern i karriären. Förra året vann hon ett försök i New Jersey Sire Stakes ($25.000).</p>
<p>Prislappen för henne i Lexington var 60.000 dollar och Material Girl är undan <strong>Lilu Hanover</strong> (e. Andover Hall), 1.10,3/$223.573, vilken tränades av Jimmy Takter och vann bland annat en division av Bluegrass Series ($84.250) på Red Mile.</p>
<p>Lilu Hanover är helsyster med<strong> Luckycharm Hanover</strong>, 1.09,6ak/3.851.039 kr, som tävlade för Daniel Redén, vann 14 lopp och slutade trea i Grand Criterium de Vitesse. Mormor <strong>Lady Luck Hanover</strong> (e. Donerail), TT 1.13,7/$6.712, är undan absoluta världsrekordhållaren <strong>Beat the Wheel</strong> (e. Defiant Yankee), 1.09,5*/$303.178.</p>
<h2>Vann med huvud</h2>
<p>Ytterligare ett försök i New Jersey Sire Stakes hölls för de treåriga stona och Tony Alagna-tränade <strong>Beltassima</strong> (e. Trixton-Beltane Hanover) avgjorde med huvud i spurten på 1.10,5 för Andrew McCarthy i ett lopp där Marcus Melanders Imhatra Am (e. Muscle Hill) var fyra på 1.10,9 och Lucas Wallins Autumn Deo (e. Muscle Hill) femma på 1.11,0.</p>
<figure id="attachment_167024" aria-describedby="caption-attachment-167024" style="width: 617px" class="wp-caption aligncenter"><a href="https://sulkysport.se/wp-content/uploads/2021/05/beltassima2152021lisa.jpg"><img class="size-sulky-mellan2 wp-image-167024" src="https://sulkysport.se/wp-content/uploads/2021/05/beltassima2152021lisa-617x346.jpg" alt="" width="617" height="346" /></a><figcaption id="caption-attachment-167024" class="wp-caption-text">Beltassima avgör med huvud. Foto: Lisa Photo</figcaption></figure>
<p>Stoet tog sin största seger i karriären efter ha vunnit lopp med 3.000 respektive 2.500 dollar i förstapris tidigare. Beltassima köptes för 27.000 dollar i Lexington och hon är undan <strong>Beltane Hanover</strong> (e. Andover Hall), 1.13,7/$15.147, vilken ingår i samma syskonskara som <strong>Brumal Hanover</strong> ($253.493), <strong>Blackberry Hanover</strong> ($209.314) och <strong>Bookworm Hanover</strong> ($103.945).</p>
<h2>Tangerat banrekord i Chester</h2>
<p>På Harrah&#8217;s Philadelphia i Chester hölls det försök i Pennsylvania Sire Stakes ($48.645) för treåriga ston och <strong>Anoka Hanover</strong> (e. Donato Hanover-Aunt Mel) imponerade stort när Noel Daleys sto tangerade Whose Blues banrekord från ifjol för Todd McCarthy på 1.10,0.</p>
<figure id="attachment_105054" aria-describedby="caption-attachment-105054" style="width: 617px" class="wp-caption aligncenter"><a href="https://sulkysport.se/wp-content/uploads/2020/08/anokahanover1082020chrisgooden.jpg"><img class="size-sulky-mellan2 wp-image-105054" src="https://sulkysport.se/wp-content/uploads/2020/08/anokahanover1082020chrisgooden-617x347.jpg" alt="" width="617" height="347" /></a><figcaption id="caption-attachment-105054" class="wp-caption-text">Anoka Hanover och Andrew McCarthy vid en tidigare seger. Foto: Chris Gooden</figcaption></figure>
<p>Duon lämnade femte inner 700 kvar, flög fram över sista långsidan och satte kniven i ledande Mazzarati i sista sväng och försvann ifrån med drygt tre längder. Lucas Wallin-tränade Mazzarati (e. Cantab Hall) var tvåa på 1.10,3 och fjärdeplatsen gick till Marcus Melanders Ineffable (e. Cantab Hall) på 1.10,7.</p>
<p>Förra året valdes Anoka Hanover till ”Årets Sto” bland tvååringarna i USA och som hon såg ut igår blir hon en tuff nöt för de andra stona i 2018-kullen att knäcka. Triumfen var hennes elfte på 15 starter.</p>
<p>Ifjol tog Anoka Hanover hem en rad storlopp; Goldsmith Maid ($451.800), Kindergarten Classic ($252.340), Bluegrass Series ($88.000), International Stallion Stake ($75.750) och John Simpson Memorial ($56.400).</p>
<p>Anoka Hanover kostade 35.000 dollar i Harrisburg som ettåring. Hon är undan <strong>Aunt Mel</strong> (e. Yankee Glide), 1.10,9*/$279.528. Modern är halvsyster med <strong>Aequitas</strong> (e. Glidemaster), 1.11,1/$155.286.</p>
<h2>Enkelt från spets</h2>
<p>Andra försöket i Pennsylvania Sire Stakes gick till Jeff Gregory bakom egentränade <strong>You Ato Dream</strong> (e. Donato Hanover-Dream Child) och från spets vann duon med drygt tre längder på 1.11,1.</p>
<p>Ifjol vann You Ato Dream en division av Liberty Bell ($37.100) och gårdagens triumf var hennes andra i karriären. Hon har också sju andraplatser på tolv starter.</p>
<p>Modern <strong>Dream Child</strong> (e. Muscle Hill), 1.11,8*/$107.556, har sin första avkomma i You Ato Dream. Själv ingår hon i samma syskonskara som <strong>Evelyn</strong> ($305.222), <strong>Gerry</strong> (1.303.933 kr) och <strong>Hannah</strong> ($99.923).</p>
<h2>Åttonde vinsten från spets</h2>
<p>Segermaskinen<strong> Love Muffin</strong> (e. Andover Hall-Pine Yankee) tog sin åttonde seger i karriären på tolv starter när hon spetsvann med trekvarts längd för Andy Miller på 1.10,1. Trea slutade Flawless Country (e. Southwind Frank) på 1.10,2 för Åke Svanstedt.</p>
<figure id="attachment_109899" aria-describedby="caption-attachment-109899" style="width: 617px" class="wp-caption aligncenter"><a href="https://sulkysport.se/wp-content/uploads/2020/09/lovemuffin792020chrisgooden.jpg"><img class="size-sulky-mellan2 wp-image-109899" src="https://sulkysport.se/wp-content/uploads/2020/09/lovemuffin792020chrisgooden-617x347.jpg" alt="" width="617" height="347" /></a><figcaption id="caption-attachment-109899" class="wp-caption-text">Love Muffin vid en tidigare triumf. Foto: Chris Gooden</figcaption></figure>
<p>Stoet är undan <strong>Pine Yankee</strong> (e. Pine Chip), 1.11,3/$99.247. Hon ingår i samma syskonskara som Breeders Crown- och Hambletonian Oaks-vinnaren <strong>Broadway Schooner</strong> (e. Broadway Hall), 1.10,2/$895.130, och världsrekordhållaren<strong> Cooler Schooner</strong> (e. Broadway Hall), 1.09,3*/$154.984.</p>
<p>Dessutom är Love Muffin är helsyster med <strong>Big Barb</strong>, 1.12,2/$66.573, vars fyraårige son är Stefan Balazsi-uppfödde Hambletonian-trean <strong>Back of the Neck</strong> (e. Ready Cash), 1.08,7/$531.097.</p>
<h2>Piper Hanover snabbast</h2>
<p>Det hölls också fem försök i Pennsylvania Stallion Series ($20.000) för treåriga ston och de vanns i tur och ordning av <strong>My Abigail</strong> (e. Bar Hopping-Pleasing Lady) på 1.12,2, <strong>Dazzling Reign</strong> (e. Father Patrick-Broadway Chuckles) på 1.12,6, <strong>Wixx Hanover</strong> (e. Donato Hanover-Whispering Wind) på 1.11,8,<strong> Piper Hanover</strong> (e. Father Patrick-Personal Style) på 1.11,0 och avrundade gjorde <strong>Evening Stroll</strong> (e. Cantab Hall-Wind Stroll) på 1.11,1.</p>

Fokustema
Utblick USA
Läs senare
Trippel svenskt på Meadowlands
Tre svenska segrar på Meadowlands i natt fördelat på lika många tränare – Åke Svanstedt, Nancy Takter och Lucas Wallin.
