<p>När Bergsåker arrangerade V75-spelet för en månad sedan så stack utdelningen iväg till 6,3 miljoner kronor.<br />
Vi kan inte påstå att lördagens övningar ser så hemskt mycket lättare ut vid en första anblick. De där givna singelstrecken tycks lysa med sin frånvaro även om vi kan plocka ut en trio som säkert blir ganska klara favoriter:</p>
<ul>
<li><strong>Algot Zonett</strong> (V75-1) gör debut i Silverdivisionen. Hur kommer han stå sig i det här sammanhanget och påverkas han av att ha de värsta konkurrenterna på insidan?</li>
<li><strong>Essie Gonzales</strong> (V75-2) vann direkt i Sverigedebuten, men mer än dubblerade sin prissumma i och med de 100.000 kronor som hon fyllde på med. Klarar hon av den tuffare uppgift hon ställs inför nu?</li>
<li><strong>Marschall Match</strong> (V75-6) övertygade vid V75-seger i Mantorp under uppesittarkvällen. Han kan öppna lika bra ur volten eller hinner Gooner svara upp och göra det jobbigt för den finskfödde femåringen?</li>
</ul>
<p><a href="https://sulkysport.se/wp-content/uploads/2021/01/09v75.pdf" target="_blank" rel="noopener noreferrer">Här kan du ta del av lördagens startlistor till Bergsåker.</a></p>
<h2>Avd 1 – Silverdivisionen, 2.140 meter autostart</h2>
<p><strong>Algot Zonett</strong> kliver upp i klass, men frågan är hur stor roll det spelar. Vi vet sedan tidigare att de bästa i brons brukar klara sig ypperligt även i silverdivisionen och i ärlighetens namn finns det många hästar som stannar väldigt länge i silver som har ett brett spann då man kan tjäna 800.000 kronor i denna klass innan man behöver ta nästa steg. Det är många trötta konkurrenter med i loppet och Algot Zonett ska precis som stallkamraten <strong>Merritt</strong> ha god chans att hävda sig här med. Därmed inte sagt att han kommer till dukat bord. <strong>Remarkable Feet</strong> var tvåa i silverfinalen annandag jul trots att han fick göra mycket jobb själv. <strong>Electrial Storm</strong> är tillbaka i toppform, men riskerar att bli över från innerspår. <strong>Donners Am</strong> gick okej som trea i silver på just Bergsåker i näst senaste starten. Vintertid räcker han i de här sammanhang också.</p>
<h2>Avd 2 – Diamantstoet, 2.140 meter voltstart</h2>
<p>Kan vi få se omgångens största favorit här i <strong>Essie Gonzales</strong>? Hon vann direkt i Sverigedebuten och gav ett bra intryck då från ledningen även om hon inte ställdes inför någon större prövning. Konkurrensen hårdnar denna gång när hon samlade in 100.000 kronor på ett bräde, men det känns som att hon kommer bära de pengarna utan problem. <strong>Lupin Hålleryd</strong> kommer också från V75-seger och klarar av att gå runt fält. Hon är den givna utmanaren vid en första anblick. Den tredje hästen i loppet som också kommer från V75-vinst är <strong>Mellby Guava</strong> som nu ska jaga från 40 meters tillägg. Även hon tuff och tål spår på vägen och det känns som den här trion höjer sig över mängden.</p>
<h2>Avd 3 – Klass II, 2.640 meter autostart</h2>
<p>Ett lurigt klass II-försök där den givna favoriten saknas. <strong>Vega Face</strong> har bättrat på aktionen undan för undan och gjorde ett starkt lopp senast i Gävle trots grovjobb. Nu kör Ulf Ohlsson det fyraåriga stoet som inte räds distansen. <strong>Ants in the Pants</strong> var V75-tvåa på Umåker och höll helt okej den dagen över just denna distans. Det här loppet är inte bättre än att han ska räknas på nytt. <strong>Jockes Abbot</strong> kändes begränsad under hösten, men var klart förbättrad senast på Umåker då han dundrade runt sina konkurrenter via 1.11 sista 500 meterna. Hästen har grundstyrka och går inte räkna bort trots spår tolv. <strong>Xanthis Daiquiri</strong> vann så nyligen som på Nyårsdagen och blir allt bättre. Erik Adielsson får chansen nu när det är STL-sammanhang och det kittlar. <strong>Zodiac Kronos</strong> felade med segern klar kort före mål på Umåker. Travar han hela vägen duger han bra.</p>
<h2>Avd 4 – Kallblodsdivisionen, 2.140 meter voltstart</h2>
<p>Helt plötsligt har kallblodsloppen norröver blivit spelmässigt intressanta efter att <strong>Våler Nikolai</strong> börjat förlora travlopp. Efter en lång, framgångsrik säsong har han inte varit riktigt lika vass i de två senaste starterna. Om det beror på att han tvingas tävla på skor eller ej låter vi vara osagt, men det känns inte som att han är riktigt där han varit formmässigt och därmed finns det utrymme för att spekulera i förlust på nytt. <strong>B.W.Rune</strong> var jättebra då han besegrade Våler Nikolai på just Bergsåker, men kastade sig i galopp kort efter start gången efter på Romme. Normalt sett står han på benen och han är ett givet segerbud. <strong>Vestpol Gladiator</strong> vann V75-lopp under juldagen. Han hade gärna fått ha framspår här på startvolten för att kännas riktigt het, men går inte att räkna bort. I övrigt är det många formsvaga hästar i loppet och det känns vid en första anblick som det blir svårt att hitta idéer utför den nämnda trion.</p>
<h2>Avd 5 – Gulddivisionen, 2.140 meter autostart</h2>
<p>En smålurig guldtillställning. Senast det var STL på Bergsåker så var <strong>Antonio Trot</strong> mest betrodd av deltagarna i det här loppet, men han gick sig trött utvändigt ledaren efter en tidig, kort galopp och var inte alls lika bra som i starterna dessförinnan. Han är ett stort frågetecken efter den insatsen och vi påminner om att han bara vann ett lopp under 2019 och 2020. <strong>Selmer I.H.</strong> var den som spurtade till seger på Bergsåker, men han var inte alls lika vass i starten efter på Solvalla. <strong>Grainfield Aiden</strong> var tvåa bakom Selmer I.H. på Bergsåker, följde upp med en sämre insats i guldfinalen, men studsade tillbaka med en stark insats som tvåa i Sylvesterloppet på Axevalla. Han tål att starta tätt (30 respektive 31 starter under 2019 och 2020!) och är ett givet bud. <strong>Disco Volante</strong> gick så pass starkt efter galopp i guldfinalen att han måste räknas även från bakspår. <strong>On Track Piraten</strong> vann förvisso på Romme, men det gick 1.17 sista 500 meterna och insatsen ska inte överskattas.</p>
<h2>Avd 6 – Bronsdivisionen, 2.140 meter voltstart</h2>
<p><strong>Marschall Match</strong> fick löpa ut i ledningen i Mantorp och såg väldigt fin ut då han gick undan med trygg marginal sista 100 meterna. Är han med på noterna och öppnar raskt från springspår så kan han bli svårslagen. Inifrån lär dock Daniel Wäjersten göra ett rejält försök att hålla upp med <strong>Gooner</strong>. Hästen är förvisso ny i klassen, men ska kunna hävda sig här också och såg väldigt fin ut som fastlåst in i det längsta i klass I-finalen på Solvalla. Gardner Shaw var med i samma lopp och gick jättebra som trea efter en hel del strul. Visst hade det varit att föredra ett framspår för honom – i synnerhet när de värsta konkurrenterna tilldelades det – men han ska ändå räknas med chans här. <strong>Let&#8217;s Go Ernie</strong> och <strong>Royal T.N.</strong> känns som utmanare där bakom som kan överraska.</p>
<h2>Avd 7 – Klass I, 1.640 meter autostart</h2>
<p><strong>Astronacente Zac</strong> fick en het häst på utsidan i klass I-finalen och gick sig kort och gott trött framme i tät. Nu är det ett halvvarv kortare distans, han står kvar i klassen och kan bli svårslagen från samma position. <strong>Big Shot</strong> var struken i Mantorp kvällen före julafton och det gör givetvis att det blir svårt att bedöma om han kommer kunna fortsätta uppvisa den positiva kurva som varit fallet i nuvarande regin. <strong>Morotai Degato</strong> vann klass II-finalen på Solvalla och är i toppslag, men från spår tolv står han inför en svår uppgift. <strong>Marcos Gallon</strong> känns alltjämt lite svår att värdera i de här sammanhangen, men tycks vara en plusvariant och hemmahästen <strong>Axel Ruda</strong> är inte heller borta med en vettig smygresa.</p>
