
<p class="has-drop-cap wp-block-paragraph">1Sulkysport har sammanställt två dokument med smått och gott inför dagens E3-finaler på Bergsåker. Där lyfter vi fram finalisterna, tar en titt i historieböckerna, kollar in avelshingstarna. Ja, smått och gott om de 24 finalisterna i E3 alltså!<br>Här är ett smakprov från varje klass:</p>



<p class="wp-block-paragraph"><strong>Ston: </strong>Uppfödarna Sisyfos Breeders AB i Sigtuna och Snogarps Gård i Ystad kan verkligen sträcka på sig lite extra inför E3-finalen för ston. Uppfödarna har nämligen plockat fram två finalister vardera!</p>



<p class="wp-block-paragraph">Sisyfos Breeders ropade tillbaka <strong>Knickers Sisu</strong> (e. Southwind Frank) på Elitauktionen, men sålde henne senare. Däremot har uppfödarna behållt <strong>Käraste Sisu</strong> (e. Face Time Bourbon).<br>Snogarps Gård har privat auktion av sina uppfödningar som säljs på sommaren som föl och både <strong>Karma Mearas</strong> (e. Face Time Bourbon) och <strong>Kitty Mearas</strong> (e. Face Time Bourbon) fann nya ägare sommaren 2020.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/e3-pda-vinnarens-kanonstart/" target="_blank" rel="noreferrer noopener">Smått &#038; gott om hästar och människorna bakom i E3-finalen för ston finns här!</a></p>



<p class="wp-block-paragraph"><strong>Hingstar/valacker: </strong>Carlo Pietrasanta (Allevamento della Serenissima) är deluppfödare i både E3-favoriten <strong>Expo Wise As</strong> (e. Ready Cash) och <strong>Epsom As</strong> (e. Muscle Mass). Hans mest kända uppfödning är storstjärnan <strong>Vivid Wise As</strong> (e. Yankee Glide), 1.08,6/€2.649.648, som han födde upp tillsammans med Antonio Somma. På våra breddgrader kan också nämnas <strong>Admiral As</strong> (e. Ready Cash), 1.10,8am/2.669.780 kr, nämnas.</p>



<p class="wp-block-paragraph">Tidigt bestämde sig Carlo Pietrasanta för att hålla på med hästar:<br>– Jag ville egentligen inte gå i skolan utan drogs till landsbygden, djuren och travhästarna. För min pappa förklarade jag i unga år att jag ville föda upp travhästar i framtiden och det var så allt började. Flera år tillbringade jag på universitetet, men min verkliga professor var Italiens legendariske Fausto Branchini.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/dags-for-en-ny-italienare/" target="_blank" rel="noreferrer noopener">Smått &#038; gott om hästar och människorna bakom i E3-finalen för hingstar/valacker finns här!</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/07/greatskillsdwm220725adamstromstalltz-617x396.jpeg" alt="" class="wp-image-331941"/><figcaption class="wp-element-caption">Stochampionatsvinnaren Great Skills. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2Stochampionatsvinnare och över 3,8 miljoner på kontot. Med de förutsättningarna kliver Daniel Wäjerstens toppsto <strong>Great Skills</strong> (e. Ready Cash) ut i silverdivisionsfinalen! Wäjersten drar nytta matchningsmässigt av en av Svensk Travsports nyheter i STL-sammanhang 2023, där ston som tjänade mycket pengar får chansen att starta i näst högsta klassen.</p>



<p class="wp-block-paragraph">Så gjorde Great Skills när hon imponerade enormt vid seger i silverförsöket i Eskilstuna för fyra veckor sedan.<br>– Jag hade förväntat mig en bra prestation av henne, men hon var lite bättre än jag trott med bara ett lopp i kroppen. Det känns som hästen är mer färdig i kroppen i år. Även om hon var väldigt bra och vann största loppet för stona, så var hon lite stor och gänglig. Hon känns väldigt bra och jag åker ut med en bra känsla till loppet, sade Wäjersten till V65 Direkt.</p>



<p class="wp-block-paragraph">Det blir första gången ett sto som klivit ur klassen med råge testas i en silverfinal. Stefan Melanders <strong>Digital Class</strong> (e. Super Photo Kosmos) var inkvalad till silverfinalen på Solvalla i februari, men valde istället start i stoeliten.</p>



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



<p class="has-drop-cap wp-block-paragraph">3Finaler i E3 och dessutom i STL kan borga för att utdelningen på V75 inte direkt skjuter i höjden, men så ser inte Sulkysports tipsexpert Emil Persson på saken:<br><em>”Även om vi rättar in oss i ledet och spikar storfavoriten <strong>Expo Wise As</strong> (V75-3) så tycker vi att det finns potential i omgången. Vi kompletterar nämligen med <strong>Make It A Star</strong> (V75-4) som spik som bara är tredjehandsfavorit i sitt lopp i skrivande stund och spelad på dussinet procent.”</em></p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v75-tips-bergsaker-1-juli/" target="_blank" rel="noreferrer noopener">––> Här är hela tipsgenomgången till V75 med analyser, spetsstrider, systemförslag och ranking av alla hästar.</a></p>



<p class="wp-block-paragraph"><em>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206687_V75_2023-07-01_9_5">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206688_V75_2023-07-01_9_5">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206689_V75_2023-07-01_9_5">Sulkysport Stora V75 – 15 andelar á 250 kr/styck</a></p>



<p class="wp-block-paragraph">Förutom på Bergsåker (första start 14.45) tävlas det även i Boden (start 18.30) ikväll. Där startar Sandra Eriksson sin topphäst <strong>Devils Tongue</strong> (e. Zola Boko), som faktiskt väntar på första årssegern efter fyra försök. Hästen kommer från fjärdeplatsen i silverdivisionen på hemmaplan när han nu ska försöka vinna ett dubbelklasslopp från tillägg.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/06/230701.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till lördagens tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4På torsdag är toppstammade jänkaren <strong>Jetborne</strong> (e. Walner) en av 23 hästar i Sprintermästaren i Halmstad. Och kanske kommer han ut till start för nya ägare? Avelsvärderade (i Norge) Jetborne är nämligen en av hela 39 hästar som bjuds ut på kvällens auktion på Travera.<br>Jetborne tävlade i Marcus Melanders regi i USA som unghäst och tog segerrekordet 1.10,0ak. Totalt har han sprungit i dryga halvmiljonen kronor inför torsdagens start i Sprintermästaren. <em>”Eventuella intäkter vid starterna på torsdag delas 50/50 mellan säljare och köpare – förutsatt att hästen är betald senast onsdag 6 juli,” </em>skriver säljaren inför kvällens auktion.</p>



<p class="wp-block-paragraph">Jetborne är en av 29 starthästar som är till salu. Dessutom finns sju fölston, två tvååringar och en ettåring i den digitala katalogen. Ettåringen är stoet <strong>Delivery Success</strong> (e. Bold Eagle), som är lillasyster till Breeders Crown-trean <strong>No Business</strong> (e. The Bank), som vann sju av 15 starter, och <strong>Shehuntyoudown</strong> (e. Revenue, 853.300 kr.</p>



<p class="wp-block-paragraph">Srf Stable säljer tre dräktiga fölston, där levande föl-avgiften ingår i köpet och köpeskillingen går oavkortat till FN:s flyktingorganisation UNHCR. Stona är <strong>Milou di Quattro</strong> (e. Southwind Frank), <strong>Soonerorlater</strong> (e. Going Kronos) och <strong>Apple Bottom Lindy</strong> (e. Cantab Hall).</p>



<p class="wp-block-paragraph"><a href="https://www.travera.nu/kopa-hast/" target="_blank" rel="noreferrer noopener">Här går det att följa budgivningen och se vilka hästar som ska säljas på kvällens auktion.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2019/12/jansson019-1-617x333.jpg" alt="" class="wp-image-57351"/><figcaption class="wp-element-caption">Belker. Foto Mia Törnberg/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">5Flera svenskar gör resan västerut till norska V75-banan Momarken. Huvudloppet Per Rakkestads Minneslopp hittar två svenskfödda hästar i varsin ände när det gäller deltagarnas startprissumma. Jonas Andreas Ås plockar ut fältets rikaste travare i forne Uppfödningsvinnaren <strong>Belker</strong> (e. Scarlet Knight), medan Roger Persson selar ut den näst fattigaste hästen <strong>Benzema</strong> (e. Infinitif).<br>Högsta klassen i Norge denna helg är utskrivet som ett tidslopp och är öppet för hästar med rekord på 1.11,0 eller långsammare, oavsett prissumma. Favorit är Noralf Braekkens unghäststjärna <strong>Golden Dream M.E.</strong> (e. Buzzin Brian), som vann Jarlsberg Grand Prix och slutade tvåa i norska Derbyt 2020.</p>



<p class="wp-block-paragraph">I ett tidslopp för kallblod med rekord 1.27,0 eller sämre startar Emelie Djurberg-tränade <strong>Sundbo Hero</strong> (e. Solör Stegg).</p>



<p class="wp-block-paragraph"><a href="https://www.travsport.no/pdf/MO_20230701_Baneprogram.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Momarkens tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">6Björn Goop är den ende svenske tränaren som prövar lyckan vid eftermiddagens tävlingar på Parisbanan Enghien (första start 13.23).<br><strong>Icarus Bourbon</strong> (e. Prodigious) kommer till start i Prix de la Porte Saint-Martin (€46.000) tillsammans med Francois Lagadeuc i ett lopp över 2.875 meter voltstart där vinnaren belönas med 20.700 euro.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/enghien-2023-07-01/" target="_blank" rel="noreferrer noopener">Här är startlistorna till Enghiens tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">7 Nu märks det tydligt på startlistorna att Hambletonian Stakes börjar närma sig. I natt på Meadowlands lär vi få en fingervisning inför världens mest betydelsefulla löpning. Meadowlands bjuder på dubbla divisioner i W.N. Reynolds Memorial både för treåriga hingstar/valacker och ston.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/airpower652023lisa-617x346.jpg" alt="" class="wp-image-440537"/><figcaption class="wp-element-caption">Air Power är världens snabbaste treåring 2023. Foto: Lisa Photo</figcaption></figure>



<p class="wp-block-paragraph">Svenskarna är förstås ordentligt i farten. Marcus Melander selar ut både <strong>Air Power </strong>(e. Muscle Hill) och <strong>Upstaged </strong>(e. Muscle Hill) i den första divisionen i <a rel="noreferrer noopener" href="https://racing.ustrotting.com/goto.aspx?target=12,90245" target="_blank">W.N. Reynolds Memorial </a>($35.400) och de möter årsdebuterande <strong>Volume Eight</strong> (e. Chapter Seven), vilken vann sju lopp ifjol på nio starter.<br>Marcus Melanders Air Power har i sin tur inlett säsongen med tre raka segrar och senast toppade han i finalen i New Jersey Sire Stakes ($240.000) där han travade årsbästa – 1.08,9/1.609 meter – i världen för treåringar.</p>



<p class="wp-block-paragraph">I den <a href="https://racing.ustrotting.com/goto.aspx?target=12,90246" target="_blank" rel="noreferrer noopener">andra divisionen</a> plockar Marcus Melander ut <strong>Oh Well</strong> (e. Muscle Hill), lillebror Mattias <strong>Dire Straits</strong> (e. Muscle Hill) och ytterligare tre svensktränade travare syns i startlistan; Åke Svanstedts svenskfödde <strong>Top Leader</strong> (e. Fabulous Wood), Jenny Melanders <strong>One Hundred Poof</strong> (e. Muscle Hill) samt Nancy Takters <strong>Tactical Approach</strong> (e. Tactical Landing).</p>



<p class="wp-block-paragraph">Stona tävlar också i dubbla divisoner. I den <a href="https://racing.ustrotting.com/goto.aspx?target=12,90247" target="_blank" rel="noreferrer noopener">första</a> startar Anette Lorentzons <strong>Quick Stop</strong> (e. Tactical Landing), Marcus Melanders <strong>Karaboudjan</strong> (e. Walner) samt svenskfödda duon <strong>Wild Jiggy</strong> (e. International Moni) och <strong>Bravo Angel </strong>(e. Readly Express), tränade av Åke Svanstedt respektive Jonas Czernyson.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/11/wb111222r5bond-617x346.jpg" alt="" class="wp-image-379778"/><figcaption class="wp-element-caption">Bond och Åke Svansteddt. Foto: Lisa Photo</figcaption></figure>



<p class="wp-block-paragraph">Svenskfött är det också i den <a rel="noreferrer noopener" href="https://racing.ustrotting.com/goto.aspx?target=12,90248" target="_blank">andra divisionen</a>. Åke Svanstedts <strong>Pure Hope</strong> (e. Brillantissime) och här startar han också sin stjärna <strong>Bond </strong>(e. Southwind Frank), som inlett säsongen med två raka triumfer. Marcus Melander plockar ut <strong>Swanky Hanover</strong> (e. Muscle Hill), vilken vunnit fyra av fem lopp i år och dessutom startar Nancy Takter <strong>Bella Macchiato</strong> (e. Bar Hopping) med två segrar och lika många andra- och tredjeplatser på sex starter.</p>



<p class="wp-block-paragraph">Åke Svanstedt har några andra intressanta hästar till start. Svenskfödda <strong>Jiggy Jog</strong> (e. Walner) går ut i <a href="https://racing.ustrotting.com/goto.aspx?target=12,90249" target="_blank" rel="noreferrer noopener">Six Pack </a>($112.500) för ston, medan han tar ut fyra hästar i <a href="https://racing.ustrotting.com/goto.aspx?target=12,90250" target="_blank" rel="noreferrer noopener">Crawford Farms </a>($155.140) och där gör <strong>Asteroid</strong> (e. Creatine) debut i hans regi. Övriga hästar är <strong>Ambassador Hanover</strong> (e. Chapter Seven), <strong>Rattle My Cage</strong> (e. Love You) och <strong>Southwind Tyrion</strong> (e. Muscle Hill).</p>



<p class="wp-block-paragraph">Mer svensktränat blir det genom Marcus Melanders <strong>Venerate </strong>(e. Love You), som vunnit sin enda start i år, i Arthur J Cutler Memorial ($155.200).</p>

Fokustema
Morgonsvepet
Läs senare
”Jag ville inte gå i skolan”
Svenska uppfödarna som är dubbelt så bra. Stochampionatsvinnaren i silverfinal. Spik på en tolvprocentare! Sprintermästardeltagare säljs ikväll. Svenskarnas hopp i försmak till Hambletonian.
Detta och mer i lördagens ”Sju nyheter vid sju”.
Detta och mer i lördagens ”Sju nyheter vid sju”.
