
<p class="has-drop-cap wp-block-paragraph">Bergsåker arrangerar veckans V75-omgång som håller mycket hög klass. Det handlar om finaler i såväl STL som i E3 och även om vi rätar in oss i ledet och spikar storfavoriten <strong>Expo Wise As</strong> (V75-3) så tycker vi att det finns potential i omgången.</p>



<p class="wp-block-paragraph">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.</p>



<p class="wp-block-paragraph">Vi tror hon anför hela vägen och där tar vi ett grepp gentemot spelarna i ett lopp där många kommer gardera friskt.</p>



<p class="wp-block-paragraph">Notera att det är stor risk för regn – eller för att tala klarspråk skyfall – i Sundsvall denna lördag och det kan givetvis påverka utgången av loppen markant.<br>Det som på förhand tycks vara så givet kan plötsligt framstå som raka motsatsen och vilka som påverkas mer eller mindre av det faktum kan vara svårt att värdera på förhand.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/06/01v75.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av startlistor till tävlingarna på Bergsåker.</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" target="_blank" rel="noreferrer noopener">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" target="_blank" rel="noreferrer noopener">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" target="_blank" rel="noreferrer noopener">Sulkysport Stora V75 – 15 andelar á 250 kr/styck</a></p>



<h2 class="wp-block-heading">Avd 1 – Bronsdivisionen, final, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Felicia Zet </strong>har vunnit två försök i Bronsdivisionen under gällande meeting och vid båda tillfällena har hon löst uppgifterna trots småtuff väg fram till dödspositionen. Det går att argumentera för att hon hamnat i överkomliga bronsgäng, men vi tycker faktiskt inte att den här finalen är superbra heller och även om risken – eller chansen – att hon får ta dödens på nytt är påtaglig så tycker vi att hon ska vara favorit till att lösa uppgiften.</li>



<li><strong>Cronos degli Dei </strong>såg aktionsmässigt klart förbättrad ut senast på Solvalla, men agerade segt och tappade några längder i slutkurvan när farten skruvades upp. Han kom tillbaka bra över upploppet och såg inte trött ut i mål. Nu blir det täta starter vilket kan ha positiv effekt och därtill avser Alessandro Gocciadoro att utrusta hästen med helstängt huvudlag. I Italien har hästen stundtals tävlat med murphybländare och bara det har bättrat på hans startsnabbhet så här har vi en teori om att hästen rentav skulle kunna forceras till tät och få löpa ut på innerspår vilket vore klart positivt för Ready Cash-sonens del.</li>



<li><strong>Demon</strong> flög fram i spurten i Klass I-finalen på Solvalla och visade i bronsförsöket i Tingsryd att han inte kommer ha problem att etablera sig på denna högre nivå som han nu tävlar i. Carl Johan Jepson kunde vaket forcera sin häst till tät varvet före mål och vann lekande lätt utan att behöva tömma sin häst. Demon är ingen startblixt utan lär bli över från start, men desto vassare till slut och därtill ska han nu åter tävla barfota runt om istället för barfota fram vilket likaså ger en extra skjuts.</li>



<li><strong>Marlon Boko </strong>har levererat två strålande avslutningar i följd från bakspår och hanterar det här utgångsläget bättre än stallkamraten <strong>Mellby Joker </strong>som därför skickas ner en bit i vår rank.</li>



<li><strong>Illfindmywayhome</strong> har varit rejält förbättrad i de två senaste starterna. Nu växlar man upp med jänkarvagn och skulle han få spara speeden i ryggar är vi inte främmande för att han kan överraska.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>7-6-1 <strong>B: </strong>11-3-10-4-9 <strong>C: </strong>8-2-5-12</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Demon</strong> lär bli över direkt och Mizai är klar spetsfavorit i våra ögon. När <strong>Cronos degli Dei</strong> nu ska utrustas med helstängt huvudlag kan hans dugliga startsnabbhet förbättras så till den grad att han har chans att hålla ut<strong> Felicia Zet </strong>och kanske rentav kan forceras till tät i första kurvan.</p>



<h2 class="wp-block-heading">Avd 2 – Klass II, final, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>PolePosition</strong> är den häst som imponerat mest på oss i Klass II-försöken under det gångna meetinget och han blir därav vårt tipsval. Det blev en dryg väg fram till tät för Propulsion-sonen i försöket i Gävle, men han stod pall för den inledningen och gick undan till säker seger med fyra längders marginal före <strong>Yavapai Point</strong>. Örjan Kihlström lär inte vila på hanen här trots spår åtta och vi tror att dödspositionen är en ledig plats dit han gärna söker sig.</li>



<li><strong>Anytimeisnow</strong> fick ge vika från ledningen i sitt Klass II-försök i Lindesberg näst senast då Blauer Max slank loss från hans rygg 125 meter före mål och knäppte honom i sista steget. Gången efter stod Muscle Mass-sonen för en bra långspurt med 1.12,2 sista varvet, men vi har alltjämt känslan av att det finns en växel till i hästen. Nu ska valacken tävla barfota fram för första gången samt utrustas med rycktussar och får det honom att lyfta kan det faktiskt vara så enkelt så startblixten Anytimeisnow anför från start till mål.</li>



<li><strong>Portofino</strong> stod för en stark debut i Fredrik B Larssons regi där han reparerade startgalopp till en tredjeplats med 1.11 sista varvet. Han fick god draghjälp i Östersund och löste den uppgiften från sjätte utvändigt via 1.12,3 sista kilometern och även om han skulle bli snuvad från tät nu kan han få ett mer spårsnålt upplägg vilket inte behöver vara fel i ett jämnare lopp.</li>



<li><strong>Dee Godfather</strong> fick dra &#8221;tredjespårståget&#8221; i Lindesberg och höll starkt som trea. Han såg &#8221;lavad ut&#8221; efter startgaloppen i lördags och gick i mål med sparade krafter. Markus B Svedbergs hästar visar toppform för dagen och vi tycker att den här grundkapabla Father Patrick-sonen är värd outsiderrösten.</li>



<li><strong>Burn Notice </strong>fick chansen för sent i Boden för att hinna ikapp stallkamraten <strong>Galant Ima</strong>, men avslutningen var det sannerligen inget fel på. Nu växlar Roger Nilsson upp och låter Burn Notice tävla med jänkarvagn för första gången i år vilket kan göra skillnad även om resultaten ifjol (sjätteplats som bäst på tre försök) i jänkarvagn inte utmärkte sig.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>8-5 <strong>B: </strong>1-10-3-6-11-12-4-7 <strong>C: </strong>9-2</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Portofino </strong>lyckades inte fronta från spår ett vid sitt senaste försök från just det utgångsläget. <strong>Anytimeisnow</strong> är rysligt kvick initialt och vi håller honom som spetsfavorit.</p>



<h2 class="wp-block-heading">Avd 3 – E3-final h/v, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Expo Wise As</strong> har gått fram som en ångvält på svensk mark och på kort tid blivit Europas mest hypade treåring. Hästen har vunnit på 1.12-tider över full väg i samtliga starter och näst senast raderade han ut självaste Going Kronos svenska rekord för treåriga utländska hingstar och valacker då han vann på 1.12,1. Expo Wise As har stabiliserat sig markant och senast höll han till exempel ihop travet jättebra genom första kurvan när han hängde ute i tredjespår. Vi tror att han kan laddas från start, hålla ut värsta konkurrenten och därefter släppas till tät.</li>



<li><strong>Epsom As </strong>spårade från start till mål i Breeders Course-finalen och har även han varit nere under 1.13 vid upprepade tillfällen. Han fick en enkel väg fram till tät i uttagningsloppet och var aldrig nära att lägga det loppet. Nu när han inleder med spår utvändigt om Expo Wise As känns uppgiften tuffare och vi tror det krävs galopp på favoriten samt att Epsom As åter ska hitta till tät för att han ska ta ännu en Grupp I-seger.</li>



<li><strong>S.G.Dracarys </strong>förälskade vi oss i under våren och var därför en smula förvånade över att han &#8221;bara&#8221; blev trea i sitt uttagningslopp. Hästen blev dock skarp utvändigt ledaren Capricon Trot den dagen och lade bort en del kraft under resans gång. Nu får han inleda bakom hästar och vi tror att han kommer ha en giftig avslutning i kroppen nu spår tolv till trots.</li>



<li><strong>Immortal Doc </strong>kom inte förbi Capricon Trot i uttagningsloppet, men var likväl positiv som tvåa. Han visade under fjolåret att han tillhör topparna och nu är han anmäld såväl barfota runt om som med jänkarvagn.</li>



<li><strong>Global Etalon </strong>blir bara bättre och bättre hela tiden. Efter Breeders Crown-segern från dödens i Örnsköldsvik vann han uttagningsloppet från tät och visade en startsnabbhet som kommer bli guld värd under säsongen.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>3 <strong>B: </strong>4-12-9-2-1-6 <strong>C: </strong>10-5-11-7-8</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Capricon Trot </strong>och <strong>Global Etalon</strong> är båda sanbba nog för att hålla ut <strong>Expo Wise As</strong> och <strong>Epsom As</strong>, men vi tror inte att de vill bråka med Expo Wise As utan tar hans rygg på första långsidan. Expo Wise As har nämligen blivit så pass stabil och kvick initialt att han sannolikt håller ut Epsom As.</p>



<h2 class="wp-block-heading">Avd 4 – Diamantstoet, final, 2.140 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Make It A Star </strong>tycker vi stod för en toppinsats som tvåa i försöksloppet hemma på Sundbyholm i början av juni då hon fick jaga från köposition. Hon fick långt fram i genrepet gången efter då hon hamnade bakom en trött konkurrent, men bet i så pass bra att hon likväl hann fram i god tid. Nu står hon perfekt till för att vinna starten och då tror vi hon anför det här loppet från start till mål.</li>



<li><strong>Collier I.T. </strong>vann förvisso på Vincennes i februari, men vi måste ändå säga att hon var överraskade vass vid segern i Tingsryd. Nog för att det stämde bra med tempo och klaff med positionerna, men sättet hon avgjorde på över spurtrakan var riktigt tilltalande. Hittar Carl Johan Jepson en bra rygg att följa under slutrundan utmanar hon om segern även här.</li>



<li><strong>Mahala</strong> hakade på helt okej som trea från vinnarhålet i senaste Diamantstoförsöket i Eskilstuna. Hon skulle även ha startat i Boden, men ströks den dagen och det föreligger därmed vissa frågetecken kring hennes status inför det här loppet.</li>



<li><strong>Queen Tresher</strong> skrällvann via perfekt klaff i Gävle. Det kan lösa sig bra även här om hon droppar ner i rygg på Make It A Star och vi ser henne som en given otusider.</li>



<li><strong>Young Mistress </strong>var markant förbättrad senast i Östersund, men riskerar att tappa mark från start från ett snävt startspår.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>1 <strong>B: </strong>13-10-2-4-12-7-9<strong> C: </strong>15-11-3-6-8-14-5</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Vårt tips är baserat på att <strong>Make It A Star</strong> håller ut <strong>Queen Tresher</strong> samt springspårshästarna.</p>



<h2 class="wp-block-heading">Avd 5 – Klass I, final, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Lindysmusclemania</strong> är obesegrad på svensk mark efter två starter och vi väljer att tippa honom i den här Klass I-finalen. Efter den rejäla insatsen i klart enklare omgivning i första starten på svensk mark så följde han upp med att lösa Klass I-försöket i Östersund efter att kommit fram lämpligt i ryggar på slutrundan och spurtat till knapp vinst via 1.10,7 sista varvet. Hästen bör rimligtvis ha en stegrande formkurva och även om det är första gången han har framspår bakom bilen på svensk mark så känns han som typen som ska kunna lägga iväg bra.</li>



<li><strong>Greensboro Zet </strong>visade positiva takter redan som tvåa i Mantorp och vann därefter sitt Klass I-försök från dödens. Han återföll dock i gamla galoppsynder på Solvalla då han straffade ut sig med galopp efter 25 meter och fick därefter ett blytungt lopp. Det kan sätta sina spår nu när han startar tätt och även om vi tror att han kan vara fältets bästa häst så vågar vi inte tippa honom etta utifrån osäkerhetsfaktorn i kombination med just det tuffa lopp han fick senast.</li>



<li><strong>Doctor Gio</strong> fick svar i spetsjakten senast i Östersund och togs ner invändigt. Det stämde inte helt i slutskedet, men hästen fullföljde urstarkt som trea och såg inte ut att vara tom över målgången. Skulle Lindysmusclemania inte lägga iväg sådär hiskeligt snabbt så finns det chans att Doctor Gio tar sig förbi honom direkt och rentav kan forceras till tät.</li>



<li><strong>Kingslayer Pellini </strong>fick ta dödens på slutrundan senast i Östersund och det var först i sista steget som han blev upphunnen av Lindysmusclemania. Det var en mycket positiv insats och trots spår elva är han en värdig utmanare.</li>



<li><strong>Declan</strong> var bra som dödenstvåa i årsdebuten i just ett Klass I-försök, men därefter blev han regelrätt nedplockad från tät när han startade i Bronsdivisionen. Utifrån det faktum är det svårbedömt hur man väljer att agera med honom taktiskt i det här loppet även om han säkert frontar initialt.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A:</strong> 5-4-6<strong> B: </strong>11-1-8-12-7 <strong>C: </strong>2-3-9-10</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Declan </strong>är rask iväg och har bra spetschans, men vill man verkligen köra honom i tät efter att han gav vika från den positionen senast? <strong>Greensboro Zet</strong> är osäker initialt, <strong>Lindysmusclemania</strong> har framspår för första gången på svensk mark och utifrån lär <strong>Doctor Gio</strong> och <strong>Denarius</strong> skickas med full fart.</p>



<h2 class="wp-block-heading">Avd 6 – E3-final ston, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Kinglet Bird </strong>är obesegrad fyra starter in i karriären och vi blev mäkta imponerade av henne på Färjestad. Trots att det handlade om autodebut så tog hon ledningen i ett nafs från spår fem och kontrollerade därefter loppet. När rycket kom 300 meter före mål gick det rysligt fort och stoet avslutade sista kilometern på 1.10,5 med tillsynes gott om krafter sparade. Vinner hon starten så tror vi att hon vinner loppet, men de tär tufft att spika en så pass orutinerad häst som därtill startar från stressiga spår ett för första gången.</li>



<li><strong>Eteria</strong> drog &#8221;tåget&#8221; i tredjespår i Breeders Course-filly finalen och föll med flaggan i topp som trea. Hon forcerades till tät på första långsidan i försöket och vann med lätthet utan att behöva spela ut hela registret. Eteria kan vinna lopp flera vägar och när Reijo Liljendahl nu växlar upp och låter henne tävla barfota runt om så är stoet mycket tidig i våra ögon.</li>



<li><strong>Esmeralda Bez</strong> blev framdragen av Eteria i Breeders Course-filly finalen och hann fram till vinst via ett sylvasst upplopp. Hon fick lite oväntat se sig spurtslagen av <strong>Käraste Sisu</strong> i försöket, men det kan vara så enkelt att hon är vassare bakifrån i det här skedet av karriären.</li>



<li><strong>Coral Coger </strong>kom inte förbi Knickers Sisu från dödens i försöket, men stod för en mycket stark insats. Nu kan hon äntligen få ett lite mer vilsamt lopp efter att ofta gjort jobbet själv och det finns därtill skoryck i tankarna hos tränaren Ola Åsebö.</li>



<li><strong>Esperia Font </strong>satt fast med rubbet sparat i Breeders Course-finalen och spetsvann sitt försök med lätthet. Hon är explosiv initialt och skulle hon rentav komma förbi de värsta konkurrenterna på insidan så sitter hon på trumf.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>1-2-9-10 <strong>B: </strong>5-4-3-7-12-6-11-8</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Kinglet Bird</strong> tog enkelt hand om ledningen i autodebuten senast och spår ett är ett gynnsamt utgångsläge på Bergsåker. Hon utmanas främst av<strong> Knickers Sisu</strong>, <strong>Esperia Font </strong>och framförallt pilsnabba <strong>Karma Mearas</strong>, men vi håller Kinglet Bird som spetsfavorit.</p>



<h2 class="wp-block-heading">Avd 7 – Silverdivisionen, final, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Kagan</strong> fick inte slag på L.L.Royal från dödens i Östersund, men gjorde ändå en mycket stark insats och tog striden hela vägen hem. I lördags varvade han upp med start i ett femåringslopp i Skellefteå och där sprang han 1.12,7/2.180 meter från dubbla tillägg via 1.11,7 sista varvet. Att han inte fick slag på ledaren Invisible Sun var inget att säga något om för det är en riktigt bra häst. Här tror vi att Kagan är den som kan nå till tät när han för en gång skull har ett gynnsamt utgångsläge och då måste fjolårets derbyfyra bli svårslagen.</li>



<li><strong>Great Skills </strong>imponerade stort vid sin seger i Silverdivisionen i Eskilstuna. Hon fick lägga en rejäl speed för att överta ledningen efter 700 meter, men gick ändå undan med lätthet över spurtrakan. Läser vi loppet rätt är dödensrisken påtaglig denna gång och då kan det bli tuffare för Great Skills, men vi vågar inte säga att hon inte har möjlighet att ta ner Kagan från utsidan för detta är en riktig topphäst.</li>



<li><strong>Blumen Indal </strong>slog på en underlig galopp som tredjehäst efter ett halvvarv senast i Boden. Han brukar inte uppträda på det viset och gången innan var han rejäl vid dödensvinsten i Gävle. Kan han få ryggen på Great Skills och sitta med i andra utvändigt in mot spurtrakan är det inte omöjligt att Blumen Indal blandar sig i segerstriden.</li>



<li><strong>Laredo Boko</strong> fick inte slag på <strong>L.A.Boko</strong> vid deras senaste möte i Boden. Nu har den förstnämnde ett mer gynnsamt utgångsläge och kan hamna längre fram i fältet samt i vilsam, invändig position vilket vi tycker talar till hans fördel.</li>



<li><strong>Idomenio Sisu </strong>fick för långt fram senast i Boden, men avslutade 1.09 sista 800 meterna från fjärde utvändigt och visade att hans bäst-före-datum på intet vis är passerat.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>5-7 <strong>B: </strong>6-1-3-2 <strong>C: </strong>12-11-4-10-9-8</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Global Bookmaker</strong> är mycket rask initialt. Vi tror att han spetsar och släpper till likaledes raske <strong>Kagan</strong> som lär ta emot de utvändiga med näbbar och klor.</p>


<div class="factbox full ">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									V75-FÖRSLAGET 1 JULI								</h3>
<div class="content">
<p class="wp-block-paragraph"><strong>Avd 1: </strong>1,6,7 (11,3)<br /><strong>Avd 2: </strong>1,3,5,6,8,10 (11,12)<br /><strong>Avd 3: </strong>3 Expo Wise As (4,12)<br /><strong>Avd 4: </strong>1 Make It A Star (13,10)<br /><strong>Avd 5: </strong>4,5,6,11 (1,8)<br /><strong>Avd 6: </strong>Samtliga tolv hästar (1,2)<br /><strong>Avd 7: </strong>1,5,6,7 (3,2)</p>
<p class="wp-block-paragraph"><em>3.456 rader / 1.728 kronor</em></p>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
